/* 
  数据文件
*/

/* 路径 */
//点击下载路径
const downloadPath = 'https://gitee.com/yyhb-wjx/yhb/releases'
//在线引入路径
const urlImport = 'https://yyhb-wjx.gitee.io/yhb/src/YHBTool.js'
const urlImport2 = 'https://yyhb-wjx.gitee.io/yhb/src/YHBTool.module.js'
//本地引入路径
const libImport = './utils/lib/YHBTool.js'
const libImport2 = '@/utils/lib/YHBTool.module.js'
const libImport3 = '@/utils/lib/YHBTool.module.js'

/* 主要数据列表 */
const htmlSpace = '&nbsp&nbsp&nbsp&nbsp'
const listData = [
  {
    id: '1',
    name: 'userInput',
    type: 'Object',
    typeText: '对象',
    describe: '对原生prompt方法进行封装',
    data: [
      {
        name: 'Null',
        describe:
          '禁止用户输入空字符串，会在判断为空时跳出alert。循环提示，直到输入正确',
        parameter: [
          {
            name: 'promptInfo',
            type: 'String',
            describe: '原生prompt提示框的提示文字。',
            default: "'请输入：'"
          },
          {
            name: 'errInfoNull',
            type: 'String',
            describe: '用户输入为空时alert的提示文字。',
            default: "'输入为空！'"
          }
        ],
        return: [
          {
            type: 'String',
            describe: '返回用户输入非空时的字符串'
          }
        ],
        example: [
          "const a = userInput.Null('请输入：','您的输入为空！')"
        ]
      },
      {
        name: 'ArrLimit',
        describe:
          '限定用户仅可以输入给定数组中的内容，会在判断不符合数组中任意一项时跳出alert。循环提示，直到输入正确',
        parameter: [
          {
            name: 'arr',
            type: 'Array',
            describe: '存放限定内容的数组'
          },
          {
            name: 'promptInfo',
            type: 'String',
            describe: '原生prompt提示框的提示文字。',
            default: "'请输入：'"
          },
          {
            name: 'errQualifiedInfo',
            type: 'String',
            describe: '用户输入不符合数组内容时alert的提示文字。',
            default: "'非限定字符！'"
          },
          {
            name: 'errInfoNull',
            type: 'String',
            describe: '用户输入为空时alert的提示文字。',
            default: "'输入为空！'"
          }
        ],
        return: [
          {
            type: 'String',
            describe: '返回用户输入验证正确时的字符串'
          }
        ],
        example: [
          "const a = userInput.ArrLimit(['1','2','3','4'],'请输入：','您的输入不符合规范！','您的输入为空！')"
        ]
      },
      {
        name: 'Number',
        describe:
          '限定用户仅可以输入数字，会在判断不为数字时跳出alert。循环提示，直到输入正确',
        parameter: [
          {
            name: 'promptInfo',
            type: 'String',
            describe: '原生prompt提示框的提示文字。',
            default: "'请输入数字：'"
          },
          {
            name: 'errInfoNaN',
            type: 'String',
            describe: '用户输入不为数字时alert的提示文字。',
            default: "'非数字！'"
          },
          {
            name: 'errInfoNull',
            type: 'String',
            describe: '用户输入为空时alert的提示文字。',
            default: "'输入为空！'"
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回用户输入验证正确时的字符串，并转换为数字'
          }
        ],
        example: [
          "const a = userInput.Number('请输入：','您的输入不是数字！','您的输入为空！')"
        ]
      },
      {
        name: 'NumberScope',
        describe:
          '限定用户仅可以输入限定范围内的数字，会在判断不为数字和不在数字区间时跳出alert。循环提示，直到输入正确',
        parameter: [
          {
            name: 'min',
            type: 'Number',
            describe: '数字范围下限',
            default: '0'
          },
          {
            name: 'max',
            type: 'Number',
            describe: '数字范围上限',
            default: '1'
          },
          {
            name: 'promptInfo',
            type: 'String',
            describe: '原生prompt提示框的提示文字',
            default: "'请输入数字：'"
          },
          {
            name: 'errScopeInfo',
            type: 'String',
            describe: '用户输入不是限定范围内数字时alert的提示文字',
            default: "'超过数字范围！'"
          },
          {
            name: 'errInfoNaN',
            type: 'String',
            describe: '用户输入不为数字时alert的提示文字',
            default: "'非数字！'"
          },
          {
            name: 'errInfoNull',
            type: 'String',
            describe: '用户输入为空时alert的提示文字',
            default: "'输入为空！'"
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回用户输入验证正确时的字符串，并转换为数字'
          }
        ],
        example: [
          "const a = userInput.NumberScope(0,10,'请输入：','超过数字范围！','您的输入不是数字！','您的输入为空！')"
        ]
      }
    ]
  },
  {
    id: '2',
    name: '方法简写',
    type: 'Function',
    typeText: '函数',
    describe: '对原生js进行方法简写包装，备用方案，不建议经常使用',
    data: [
      {
        name: 'log',
        describe: '原生 console.log 简化',
        parameter: [
          {
            name: 'logMsg',
            type: 'any',
            describe: '控制台输出信息',
            default: "''"
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ["log('hello!')"]
      },
      {
        name: 'dir',
        describe: '原生 console.dir 简化',
        parameter: [
          {
            name: 'dirMsg',
            type: 'any',
            describe: '控制台输出信息',
            default: "''"
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ['dir([1,2,3])']
      },
      {
        name: 'err',
        describe: '原生 console.error 简化',
        parameter: [
          {
            name: 'errMsg',
            type: 'any',
            describe: '控制台输出信息',
            default: "''"
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ["err('错误信息！')"]
      },
      {
        name: 'dq',
        describe: '原生 document.querySelector 简化，但是加上了未找到元素的异常判断。<br>执行到此句时，若未找到元素，会立即执行异常报错',
        parameter: [
          {
            name: 'element',
            type: 'String',
            describe: '元素的css选择器或者元素'
          }
        ],
        return: [
          {
            type: 'element',
            describe: '元素'
          }
        ],
        example: ["const box = dq('.box')"]
      },
      {
        name: 'dqa',
        describe: '原生 document.querySelectorAll 简化，但是加上了未找到元素的异常判断。<br>执行到此句时，若未找到元素，会立即执行异常报错',
        parameter: [
          {
            name: 'elements',
            type: 'String',
            describe: '元素的css选择器或者元素伪数组'
          }
        ],
        return: [
          {
            type: 'elements',
            describe: '元素伪数组'
          }
        ],
        example: ["const box = dqa('.box')"]
      }
    ]
  },
  {
    id: '3',
    name: '$Log',
    type: 'Object',
    typeText: '对象',
    describe: '控制台相关，包含浮窗型控制台，详见Float',
    data: [
      {
        name: 'Line',
        describe: '将数组内容依次打印在控制台',
        parameter: [
          {
            name: 'arr',
            type: 'Array',
            describe: '存放打印内容的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ['$Log.Line([1,2,3,4])']
      },
      {
        name: 'Color',
        describe: '打印指定颜色的内容到控制台',
        parameter: [
          {
            name: 'info',
            type: 'any',
            describe: '打印内容',
            default: "''"
          },
          {
            name: 'color',
            type: 'String',
            describe: '文字颜色',
            default: "''"
          },
          {
            name: 'backgroundColor',
            type: 'String',
            describe: '背景颜色',
            default: "''"
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ["$Log.Color('示例消息','green','red')"]
      },
      {
        name: 'Float',
        describe:
          '浮窗型控制台，将控制台移动到页面上。<br/>此方法接管了大部分的异常显示以及原生console方法，如果使用console.log,console,dir,console.error等，将不会在浏览器控制台看到消息。<br/>已经包装了输入框，可以直接输入表达式，使用eval方法实现。<br/>对于很多异常，已经用中文进行解释。并且异常情况可以点击直接跳转百度。<br/>可以点击折叠，清空消息。标题栏位置可以任意拖动此浮窗',
        parameter: [
          {
            name: 'msg',
            type: 'any',
            describe:
              '打印内容。一般不推荐使用此参数，因为已经接管了console中的部分常用方法。可以直接使用console.log,console,dir,console.error等',
            default: "''"
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ['$Log.Float()']
      }
    ]
  },
  {
    id: '4',
    name: 'formatSecond',
    type: 'Function',
    typeText: '函数',
    describe:
      '秒数格式化，根据输入秒数，转化为年月日时分秒格式，如果某一项为零则不打印',
    data: [
      {
        parameter: [
          {
            name: 'second',
            type: 'Number',
            describe: '秒数',
            default: '0'
          },
          {
            name: 'separatorYMD',
            type: 'String',
            describe: '年月日分隔符',
            default: '/'
          },
          {
            name: 'separatorDH',
            type: 'String',
            describe: '日与时的分隔符',
            default: '空格'
          },
          {
            name: 'separatorHMS',
            type: 'String',
            describe: '时分秒分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'String',
            describe: '返回格式转化后的字符串'
          }
        ],
        example: ["formatSecond(1000,'-',' ',':')"]
      }
    ]
  },
  {
    id: '5',
    name: 'Digit',
    type: 'Object',
    typeText: '对象',
    describe: '数字处理类，封装了很多的数字数据处理',
    data: [
      {
        isVar: true,
        name: 'PI',
        describe: '数字常量 圆周率（精确小数点后15位）'
      },
      {
        isVar: true,
        name: 'StringPI',
        describe: '字符串常量 圆周率（精确小数点后70位）'
      },
      {
        isVar: true,
        name: 'E',
        describe: '数字常量 自然对数e（精确小数点后15位）'
      },
      {
        isVar: true,
        name: 'StringE',
        describe: '字符串常量 自然对数e（精确小数点后15位）'
      },
      {
        isVar: true,
        name: 'FI',
        describe: '数字常量 黄金分割数Ф（精确小数点后15位）'
      },
      {
        isVar: true,
        name: 'StringFI',
        describe: '字符串常量 黄金分割数Ф（精确小数点后15位）'
      },
      {
        name: 'sum',
        describe: '将数组内容求和',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求和的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回计算出来的和'
          }
        ],
        example: ['Digit.sum([1,2,3,4])']
      },
      {
        name: 'min',
        describe: '输出数组中的最小值',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求最小值的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回计算出来的最小值'
          }
        ],
        example: ['Digit.min([1,2,3,4])']
      },
      {
        name: 'max',
        describe: '输出数组中的最大值',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求最大值的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回计算出来的最大值'
          }
        ],
        example: ['Digit.max([1,2,3,4])']
      },
      {
        name: 'max',
        describe: '返回数组中的全部奇数',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求全部奇数的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '数组中的全部奇数'
          }
        ],
        example: ['Digit.odd([1,2,3,4])']
      },
      {
        name: 'even',
        describe: '返回数组中的全部偶数',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求全部偶数的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '数组中的全部偶数'
          }
        ],
        example: ['Digit.even([1,2,3,4])']
      },
      {
        name: 'greater',
        describe: '返回数组中全部大于than的数，than为第二个参数',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需求数组',
            default: '[]'
          },
          {
            name: 'than',
            type: 'Number',
            describe: '大于某数',
            default: '0'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '数组中的全部大于than的数'
          }
        ],
        example: ['Digit.greater([1,2,3,4],2)']
      },
      {
        name: 'less',
        describe: '返回数组中全部小于than的数，than为第二个参数',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需求数组',
            default: '[]'
          },
          {
            name: 'than',
            type: 'Number',
            describe: '小于某数',
            default: '0'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '数组中的全部小于than的数'
          }
        ],
        example: ['Digit.less([1,2,3,4],3)']
      },
      {
        name: 'aliquot',
        describe:
          '返回数组中能被divisor整除的所有数，divisor为第二个参数',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求能被某个数整除的数组',
            default: '[]'
          },
          {
            name: 'divisor',
            type: 'Number',
            describe: '其他数能被此数整除',
            default: '0'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '数组中的全部能被divisor整除的数'
          }
        ],
        example: ['Digit.aliquot([1,2,3,4],2)']
      },
      {
        name: 'prime',
        describe: '返回数组中的全部质数',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求全部质数的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '数组中的全部质数'
          }
        ],
        example: ['Digit.prime([1,2,3,4,5,6])']
      },
      {
        name: 'composite',
        describe: '返回数组中的全部合数',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要求全部合数的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '数组中的全部合数'
          }
        ],
        example: ['Digit.composite([1,2,3,4,5,6])']
      },
      {
        name: 'ascending',
        describe: '升序排列数组',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要被升序排列的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '升序排列后的数组'
          }
        ],
        example: ['Digit.ascending([1,2,3,4,5,6])']
      },
      {
        name: 'descending',
        describe: '降序排列数组',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '需要被降序排列的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '降序排列后的数组'
          }
        ],
        example: ['Digit.descending([1,2,3,4,5,6])']
      },
      {
        name: 'Place',
        describe: '保留指定小数位数(直接保留，不四舍五入)',
        parameter: [
          {
            name: 'num',
            type: 'Float',
            describe: '需要保留小数位数的数字',
            default: '0.0'
          },
          {
            name: 'place',
            type: 'Number',
            describe: '保留位数',
            default: '2'
          }
        ],
        return: [
          {
            type: 'Float',
            describe: '保留后的数字'
          }
        ],
        example: ['Digit.Place(2.3568,3)']
      },
      {
        name: 'PlaceRounded',
        describe: '保留指定小数位数(四舍五入)',
        parameter: [
          {
            name: 'num',
            type: 'Float',
            describe: '需要保留小数位数的数字',
            default: '0.0'
          },
          {
            name: 'place',
            type: 'Number',
            describe: '四舍五入保留位数',
            default: '2'
          }
        ],
        return: [
          {
            type: 'Float',
            describe: '保留后的数字'
          }
        ],
        example: ['Digit.PlaceRounded(2.3568,3)']
      },
      {
        name: 'randomInt',
        describe: '获取整数随机数',
        parameter: [
          {
            name: 'min',
            type: 'Number',
            describe: '随机整数的最小值',
            default: '0'
          },
          {
            name: 'max',
            type: 'Number',
            describe: '随机整数的最大值',
            default: '10'
          },
          {
            name: 'closed',
            type: 'Boolean',
            describe: '是否需要包含最大值',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回随机数'
          }
        ],
        example: ['Digit.randomInt(5,12,true)']
      },
      {
        name: 'randomFloat',
        describe: '获取小数随机数',
        parameter: [
          {
            name: 'min',
            type: 'Number',
            describe: '随机整数的最小值',
            default: '0'
          },
          {
            name: 'max',
            type: 'Number',
            describe: '随机整数的最大值',
            default: '10'
          },
          {
            name: 'closed',
            type: 'Boolean',
            describe: '是否需要包含最大值',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'Float',
            describe: '返回随机数'
          }
        ],
        example: ['Digit.randomFloat(5,12,true)']
      },
      {
        name: 'toCN',
        describe: '将0-10的数字转换为中文，可设置是否繁体',
        parameter: [
          {
            name: 'num',
            type: 'Number',
            describe: '需要转换的数字',
            default: '0'
          },
          {
            name: 'Traditional',
            type: 'Boolean',
            describe: '是否需要返回繁体',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'String | NaN',
            describe: '返回转换后的字符串或者NaN'
          }
        ],
        example: ['Digit.toCN(5,true)']
      },
      {
        name: 'average',
        describe: '将数组中的数据求平均值',
        parameter: [
          {
            name: 'numArr',
            type: 'Array',
            describe: '求平均值的数组',
            default: '[]'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回计算后的平均值'
          }
        ],
        example: ['Digit.average([1,2,3,4,5])']
      }
    ]
  },
  {
    id: '6',
    name: 'Str',
    type: 'Object',
    typeText: '对象',
    describe: '字符串处理类',
    data: [
      {
        name: 'subArr',
        describe: '分离字符串中的数字、字母与其他字符三类',
        parameter: [
          {
            name: 'str',
            type: 'String',
            describe: '需要处理的字符串',
            default: "''"
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '返回分离后的数组'
          }
        ],
        example: ["Str.subArr('a1s2d3+-dwq84d5')"]
      },
      {
        name: 'removeSpace',
        describe: '去除字符串首尾空格',
        parameter: [
          {
            name: 'str',
            type: 'String',
            describe: '需要处理的字符串',
            default: "''"
          }
        ],
        return: [
          {
            type: 'String',
            describe: '返回去除空格后的字符串'
          }
        ],
        example: ["Str.removeSpace(' a1s2d3+-dwq84d5 ')"]
      },
      {
        name: 'removeAllSpace',
        describe: '去除字符串中的全部空格',
        parameter: [
          {
            name: 'str',
            type: 'String',
            describe: '需要处理的字符串',
            default: "''"
          }
        ],
        return: [
          {
            type: 'String',
            describe: '返回去除空格后的字符串'
          }
        ],
        example: ["Str.removeAllSpace(' a1 s2 d3 +- dwq 84 d5 ')"]
      },
      {
        name: 'section',
        describe:
          '将字符串中的字符每num个为一组，储存为数组，不足字数的直接储存。num为第二个参数',
        parameter: [
          {
            name: 'str',
            type: 'String',
            describe: '需要处理的字符串',
            default: "''"
          },
          {
            name: 'num',
            type: 'Number',
            describe: '分段的字数',
            default: '1'
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '返回根据num数量分组后的数组'
          }
        ],
        example: ["Str.section('88888888888888888',3)"]
      },
      {
        name: 'subChar',
        describe:
          '将字符串按照char指定字符分割成数组，char为第二个参数',
        parameter: [
          {
            name: 'str',
            type: 'String',
            describe: '需要处理的字符串',
            default: "''"
          },
          {
            name: 'char',
            type: 'String',
            describe: '分割字符',
            default: "''"
          }
        ],
        return: [
          {
            type: 'Array',
            describe: '返回根据char切割后的数组'
          }
        ],
        example: ["Str.subChar('888288288882888882888','2')"]
      },
      {
        name: 'replace',
        describe:
          '将字符串中的每个targetStr都替换成replaceStr，targetStr与replaceStr分别为第二个和第三个参数',
        parameter: [
          {
            name: 'str',
            type: 'String',
            describe: '需要处理的字符串',
            default: "''"
          },
          {
            name: 'targetStr',
            type: 'String',
            describe: '目标字符',
            default: "''"
          },
          {
            name: 'replaceStr',
            type: 'String',
            describe: '替换字符',
            default: "''"
          }
        ],
        return: [
          {
            type: 'String',
            describe: '返回替换后的字符串'
          }
        ],
        example: ["Str.replace('888288288882888882888','8','3')"]
      }
    ]
  },
  {
    id: '7',
    name: 'Char',
    type: 'Object',
    typeText: '对象',
    describe: '字符处理类',
    data: [
      {
        name: 'isLowercase',
        describe: '判断字符是否为小写字母',
        parameter: [
          {
            name: 'char',
            type: 'String(char)',
            describe: '字符',
            default: "''"
          }
        ],
        return: [
          {
            type: 'Boolean',
            describe: '是否为小写字母'
          }
        ],
        example: ["Char.isLowercase('a')"]
      },
      {
        name: 'isUppercase',
        describe: '判断字符是否为大写字母',
        parameter: [
          {
            name: 'char',
            type: 'String(char)',
            describe: '字符',
            default: "''"
          }
        ],
        return: [
          {
            type: 'Boolean',
            describe: '是否为大写字母'
          }
        ],
        example: ["Char.isUppercase('A')"]
      }
    ]
  },
  {
    id: '8',
    name: 'Color',
    type: 'Object',
    typeText: '对象',
    describe: '颜色转换类',
    data: [
      {
        name: 'toHex',
        describe: '将RGB转换为16进制，默认不加#号',
        parameter: [
          {
            name: 'RRgb',
            type: 'Number | String',
            describe: '红色数值或者rgb格式字符串',
            default: '0'
          },
          {
            name: 'G',
            type: 'Number',
            describe: '绿色数值',
            default: '0'
          },
          {
            name: 'B',
            type: 'Number',
            describe: '绿色数值',
            default: '0'
          }
        ],
        return: [
          {
            type: 'String',
            describe: '此颜色的十六进制'
          }
        ],
        example: [
          'Color.toHex(21,23,24)',
          "Color.toHex('rgb(21,23,24)')"
        ]
      }
    ]
  },
  {
    id: '9',
    name: 'Timer',
    type: 'Object',
    typeText: '对象',
    describe: '计时器相关方法',
    data: [
      {
        name: 'countdown',
        describe: '将给定元素的内容变成倒计时',
        parameter: [
          {
            name: 'element',
            type: 'String',
            describe: '需要用来显示的元素'
          },
          {
            name: 'start',
            type: 'Number',
            describe: '倒计时的开始时间',
            default: '10'
          },
          {
            name: 'end',
            type: 'Number',
            describe: '倒计时的结束时间,一般不修改',
            default: '0'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ["Timer.countdown('.box',20)"]
      },
      {
        name: 'timing',
        describe: '将给定元素的内容变成正向计时',
        parameter: [
          {
            name: 'element',
            type: 'String',
            describe: '需要用来显示的元素'
          },
          {
            name: 'end',
            type: 'Number',
            describe: '计时的结束时间',
            default: '10'
          },
          {
            name: 'start',
            type: 'Number',
            describe: '计时的开始时间,一般不修改',
            default: '0'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ["Timer.timing('.box',20)"]
      },
      {
        name: 'shuffling',
        describe: '将数组的内容依次刷新显示',
        parameter: [
          {
            name: 'element',
            type: 'String',
            describe: '需要用来显示的元素'
          },
          {
            name: 'arr',
            type: 'Array',
            describe: '顺序依次显示的数组',
            default: '[]'
          },
          {
            name: 'interval',
            type: 'Number',
            describe: '间隔时间(毫秒)',
            default: '1000'
          },
          {
            name: 'cycle',
            type: 'Boolean',
            describe: '是否一直从头循环',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ["Timer.shuffling('.box',[1,2,3,4,5],1000,true)"]
      },
      {
        name: 'shufflingIMGPoint',
        describe: '循环轮播图与进度点，古老方案',
        parameter: [
          {
            name: 'imgElement',
            type: 'Element | String',
            describe: '需要用来更换图片的img标签元素或CSS选择器'
          },
          {
            name: 'pointElement',
            type: 'Element | String',
            describe:
              '需要用来显示轮换进度的同名兄弟标签元素的CSS选择器'
          },
          {
            name: 'pointActiveClassName',
            type: 'String',
            describe: '需要用来轮换的同名兄弟标签元素的样式类名'
          },
          {
            name: 'arrURL',
            type: 'Array',
            describe: '顺序依次显示的图片路径数组',
            default: '[]'
          },
          {
            name: 'interval',
            type: 'Number',
            describe: '间隔时间(毫秒)',
            default: '1000'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: [
          "Timer.shufflingIMGPoint('.img-box','.point-box','active',['./img/1.png','./img/2.png','./img/3.png','./img/4.png'],1000)"
        ]
      },
      {
        name: 'shufflingIMGPointBtn',
        describe: '循环轮播图与进度点与前后切换按钮，古老方案',
        parameter: [
          {
            name: 'superiorElement',
            type: 'Element | String',
            describe: '轮播图全组件的父元素或CSS选择器'
          },
          {
            name: 'imgElement',
            type: 'Element | String',
            describe: '需要用来更换图片的img标签元素或CSS选择器'
          },
          {
            name: 'pointElement',
            type: 'Element | String',
            describe:
              '需要用来显示轮换进度的同名兄弟标签元素的CSS选择器'
          },
          {
            name: 'pointActiveClassName',
            type: 'String',
            describe: '需要用来轮换的同名兄弟标签元素的样式类名'
          },
          {
            name: 'prevBtn',
            type: 'String',
            describe: '显示上一张的按钮或点击元素或CSS选择器'
          },
          {
            name: 'nextBtn',
            type: 'String',
            describe: '显示下一张的按钮或点击元素或CSS选择器'
          },
          {
            name: 'arrURL',
            type: 'Array',
            describe: '顺序依次显示的图片路径数组',
            default: '[]'
          },
          {
            name: 'time',
            type: 'Number',
            describe: '间隔时间(毫秒)',
            default: '1000'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: [
          "Timer.shufflingIMGPointBtn('.box','.img-box','.point-box','active','.prevBtn','.nextBtn',['./img/1.png','./img/2.png','./img/3.png','./img/4.png'],1000)"
        ]
      }
    ]
  },
  {
    id: '10',
    name: 'FormatDate',
    type: 'Object',
    typeText: '对象',
    describe: '时间处理类',
    data: [
      {
        name: 'isLeapYear',
        describe: '输入年份是否为闰年，默认为今年',
        parameter: [
          {
            name: 'year',
            type: 'String | Number',
            describe: '年份'
          }
        ],
        return: [
          {
            type: 'Boolean',
            describe: '返回今年是否为闰年的判断'
          }
        ],
        example: ['FormatDate.isLeapYear(2020)']
      },
      {
        name: 'getInitial',
        describe: '获取本年的初始时间，可自定义分隔符的年月日时分秒',
        parameter: [
          {
            name: 'needHMS',
            type: 'Boolean',
            describe: '是否需要返回时分秒'
          },
          {
            name: 'SeparatorYMD',
            type: 'string',
            describe: '年月日的分隔符',
            default: '-'
          },
          {
            name: 'SeparatorDH',
            type: 'string',
            describe: '日与时之间的分隔符',
            default: '空格'
          },
          {
            name: 'SeparatorHMS',
            type: 'string',
            describe: '时分秒的分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回本年的初始时间'
          }
        ],
        example: ['FormatDate.getInitial(true)']
      },
      {
        name: 'getEnd',
        describe: '获取本年的末尾时间，可自定义分隔符的年月日时分秒',
        parameter: [
          {
            name: 'needHMS',
            type: 'Boolean',
            describe: '是否需要返回时分秒'
          },
          {
            name: 'SeparatorYMD',
            type: 'string',
            describe: '年月日的分隔符',
            default: '-'
          },
          {
            name: 'SeparatorDH',
            type: 'string',
            describe: '日与时之间的分隔符',
            default: '空格'
          },
          {
            name: 'SeparatorHMS',
            type: 'string',
            describe: '时分秒的分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回本年的末尾时间'
          }
        ],
        example: ['FormatDate.getEnd(true)']
      },
      {
        name: 'getWeekInitial',
        describe: '获取本周的初始时间，可自定义分隔符的月日时分秒',
        parameter: [
          {
            name: 'needHMS',
            type: 'Boolean',
            describe: '是否需要返回时分秒'
          },
          {
            name: 'needY',
            type: 'Boolean',
            describe: '是否需要返回年'
          },
          {
            name: 'SeparatorYMD',
            type: 'string',
            describe: '年月日的分隔符',
            default: '-'
          },
          {
            name: 'SeparatorDH',
            type: 'string',
            describe: '日与时之间的分隔符',
            default: '空格'
          },
          {
            name: 'SeparatorHMS',
            type: 'string',
            describe: '时分秒的分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回本周的初始时间'
          }
        ],
        example: ['FormatDate.getWeekInitial(true,false)']
      },
      {
        name: 'getMonthInitial',
        describe: '获取本月的初始时间，可自定义分隔符的月日时分秒',
        parameter: [
          {
            name: 'needHMS',
            type: 'Boolean',
            describe: '是否需要返回时分秒'
          },
          {
            name: 'needY',
            type: 'Boolean',
            describe: '是否需要返回年'
          },
          {
            name: 'SeparatorYMD',
            type: 'string',
            describe: '年月日的分隔符',
            default: '-'
          },
          {
            name: 'SeparatorDH',
            type: 'string',
            describe: '日与时之间的分隔符',
            default: '空格'
          },
          {
            name: 'SeparatorHMS',
            type: 'string',
            describe: '时分秒的分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回本月的初始时间'
          }
        ],
        example: ['FormatDate.getMonthInitial(true,false)']
      },
      {
        name: 'getMonthEnd',
        describe: '获取本月的末尾时间，可自定义分隔符的月日时分秒',
        parameter: [
          {
            name: 'needHMS',
            type: 'Boolean',
            describe: '是否需要返回时分秒'
          },
          {
            name: 'needY',
            type: 'Boolean',
            describe: '是否需要返回年'
          },
          {
            name: 'SeparatorYMD',
            type: 'string',
            describe: '年月日的分隔符',
            default: '-'
          },
          {
            name: 'SeparatorDH',
            type: 'string',
            describe: '日与时之间的分隔符',
            default: '空格'
          },
          {
            name: 'SeparatorHMS',
            type: 'string',
            describe: '时分秒的分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回本月的末尾时间'
          }
        ],
        example: ['FormatDate.getMonthEnd(true,false)']
      },
      {
        name: 'getHMS',
        describe: '获取自定义分隔符的时分秒',
        parameter: [
          {
            name: 'SeparatorHMS',
            type: 'string',
            describe: '时分秒的分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回时分秒'
          }
        ],
        example: ["FormatDate.getHMS('.')"]
      },
      {
        name: 'getYMD',
        describe: '获取自定义分隔符的年月日',
        parameter: [
          {
            name: 'SeparatorYMD',
            type: 'string',
            describe: '年月日的分隔符',
            default: '-'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回年月日'
          }
        ],
        example: ["FormatDate.getYMD('/')"]
      },
      {
        name: 'getDate',
        describe: '获取自定义分隔符的年月日时分秒',
        parameter: [
          {
            name: 'SeparatorYMD',
            type: 'string',
            describe: '年月日的分隔符',
            default: '-'
          },
          {
            name: 'SeparatorDH',
            type: 'string',
            describe: '日与时之间的分隔符',
            default: '空格'
          },
          {
            name: 'SeparatorHMS',
            type: 'string',
            describe: '时分秒的分隔符',
            default: ':'
          }
        ],
        return: [
          {
            type: 'string',
            describe: '返回年月日时分秒'
          }
        ],
        example: ["FormatDate.getDate('/')"]
      },
      {
        name: 'getDaysPerMonth',
        describe: '获取指定月份的总天数，默认本月',
        parameter: [
          {
            name: 'mouth',
            type: 'Number',
            describe: '月份'
          },
          {
            name: 'year',
            type: 'Number',
            describe: '年份,默认本年'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '总天数'
          }
        ],
        example: ['FormatDate.getDaysPerMonth(2,2010)']
      },
      {
        name: 'getDaysPerYear',
        describe: '获取指定年份的总天数，默认本年',
        parameter: [
          {
            name: 'year',
            type: 'Number',
            describe: '年份'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '总天数'
          }
        ],
        example: ['FormatDate.getDaysPerYear(2010)']
      },
      {
        name: 'getWeek',
        describe: '获取当前的星期数',
        parameter: [
          {
            name: 'type',
            type: 'String',
            describe: '需要显示什么类型。cn：中文 en：英文。默认数字',
            default: 'number'
          },
          {
            name: 'Abbreviation',
            type: 'Boolean',
            describe: '是否需要返回简写形式',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'String | Number',
            describe: '返回当前星期数'
          }
        ],
        example: ["FormatDate.getWeek('cn','true')"]
      },
      {
        name: 'getDay',
        describe: '获取今天为当月的第几天',
        parameter: [
          {
            name: 'format',
            type: 'String',
            describe: '是否格式化，即不满两位数的在前面补零',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'String | Number',
            describe: '返回当前日'
          }
        ],
        example: ['FormatDate.getDay()']
      },
      {
        name: 'getMonth',
        describe: '获取当前月份',
        parameter: [
          {
            name: 'format',
            type: 'String',
            describe: '是否格式化，即不满两位数的在前面补零',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'String | Number',
            describe: '返回当前月份'
          }
        ],
        example: ['FormatDate.getMonth()']
      },
      {
        name: 'getYear',
        describe: '获取当前年份',
        parameter: [
          {
            name: '无'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回当前年'
          }
        ],
        example: ['FormatDate.getYear()']
      },
      {
        name: 'getHours',
        describe: '获取当前小时数',
        parameter: [
          {
            name: 'format',
            type: 'String',
            describe: '是否格式化，即不满两位数的在前面补零',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'String | Number',
            describe: '返回当前小时'
          }
        ],
        example: ['FormatDate.getHours()']
      },
      {
        name: 'getMinutes',
        describe: '获取当前分钟数',
        parameter: [
          {
            name: 'format',
            type: 'String',
            describe: '是否格式化，即不满两位数的在前面补零',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'String | Number',
            describe: '返回当前分钟'
          }
        ],
        example: ['FormatDate.getMinutes()']
      },
      {
        name: 'getSeconds',
        describe: '获取当前秒数',
        parameter: [
          {
            name: 'format',
            type: 'String',
            describe: '是否格式化，即不满两位数的在前面补零',
            default: 'false'
          }
        ],
        return: [
          {
            type: 'String | Number',
            describe: '返回当前秒数'
          }
        ],
        example: ['FormatDate.getSeconds()']
      },
      {
        name: 'getStamp',
        describe: '获取指定时间戳，默认当前时间',
        parameter: [
          {
            name: 'time',
            type: 'String',
            describe: '指定时间'
          }
        ],
        return: [
          {
            type: 'Number',
            describe: '返回时间戳'
          }
        ],
        example: ['FormatDate.getStamp()']
      }
    ]
  },
  {
    id: '11',
    name: 'Net',
    type: 'Constructor',
    typeText: '构造函数',
    describe: '网络请求类，需要使用 new 实例化',
    data: [
      {
        isVar: true,
        name: 'initial',
        describe: '可选，构造函数初始设置。<br>可设置四种初始属性：baseURL、secondUR、timeout与Authorization',
        example: [
          `const net = new Net({<br>
          ${htmlSpace}baseURL = "https://www.xxxx.com"<br>
          })`,
        ]
      },
      {
        isVar: true,
        name: 'baseURL',
        describe: '基地址',
        example: [
          'const net = new Net()',
          'net.baseURL = "https://example//example"'
        ]
      },
      {
        isVar: true,
        name: 'secondURL',
        describe: '第二层公共地址，接在基地址之后',
        example: ['const net = new Net()', 'net.secondURL = "/api"']
      },
      {
        isVar: true,
        name: 'Authorization',
        describe: '授权头',
        example: [
          'const net = new Net()',
          'net.Authorization = "1d32as1aw61da58sda5d16"'
        ]
      },
      {
        isVar: true,
        name: 'timeout',
        describe: '设置超时属性，毫秒(ms)',
        example: ['const net = new Net()', 'net.timeout = 5000']
      },
      {
        name: 'postQuery',
        describe: 'POST请求，有请求参数，不带请求体',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} params: {}, ---> 请求参数<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.postQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.postQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.postQuery({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}params:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'getQuery',
        describe: 'GET请求，有请求参数，不带请求体',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} params: {}, ---> 请求参数<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.getQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.getQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.getQuery({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}params:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'putQuery',
        describe: 'PUT请求，有请求参数，不带请求体',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} params: {}, ---> 请求参数<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.putQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.putQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.putQuery({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}params:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'deleteQuery',
        describe: 'DELETE请求，有请求参数，不带请求体',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} params: {}, ---> 请求参数<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.deleteQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.deleteQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.deleteQuery({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}params:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'patchQuery',
        describe: 'PATCH请求，有请求参数，不带请求体',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} params: {}, ---> 请求参数<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.patchQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.patchQuery({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}params:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.patchQuery({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}params:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'postBody',
        describe: 'POST请求，带请求体，没有请求参数',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} data: {}, ---> 请求体<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.postBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.postBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.postBody({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}data:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'getBody',
        describe: 'GET请求，带请求体，没有请求参数',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} data: {}, ---> 请求体<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.getBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.getBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.getBody({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}data:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'putBody',
        describe: 'PUT请求，带请求体，没有请求参数',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} data: {}, ---> 请求体<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.putBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.putBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.putBody({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}data:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'deleteBody',
        describe: 'DELETE请求，带请求体，没有请求参数',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} data: {}, ---> 请求体<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.deleteBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.deleteBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.deleteBody({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}data:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'patchBody',
        describe: 'PATCH请求，带请求体，没有请求参数',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} data: {}, ---> 请求体<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.patchBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.patchBody({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.patchBody({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}data:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'custom',
        describe: '自定义请求，可以指定请求方式，请求体与请求参数',
        parameter: [
          {
            name: 'requestContent',
            type: 'Object',
            describe: `参数传递<br/>
            {<br/>
            ${htmlSpace} url: '', ---> 请求地址(必填)<br/>
            ${htmlSpace} method: '', ---> 请求方式，不填默认GET<br/>
            ${htmlSpace} params: {},, ---> 请求参数<br/>
            ${htmlSpace} data: {}, ---> 请求体<br/>
            ${htmlSpace} headers: {} ---> 请求头设置<br/>
            }
          `
          },
          {
            name: 'callbackResult',
            type: 'Function',
            describe: '参考回调函数'
          },
          {
            name: 'callbackError',
            type: 'Function',
            describe: '参考回调函数'
          }
        ],
        return: [
          {
            type: 'Promise',
            describe: '返回请求后的Promise'
          }
        ],
        callback: [
          {
            name: 'callbackResult',
            describe:
              '请求成功时的回调，原理为Promise中的resolve抛给的.then'
          },
          {
            name: 'callbackError',
            describe:
              '请求失败时的回调，原理为Promise中的reject抛给的.catch'
          }
        ],
        callbackParameter: [
          {
            name: 'result',
            from: 'callbackResult',
            type: 'any',
            describe: '成功回调函数的第一个参数，为成功请求的返回结果'
          },
          {
            name: 'error',
            from: 'callbackError',
            type: 'any',
            describe: '失败回调函数的第一个参数，为失败请求的返回结果'
          }
        ],
        example: [
          'const net = new Net()',
          `<br/>net.custom({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}method:'POST',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        },res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>net.custom({<br/>
        ${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}method:'POST',<br/>
        ${htmlSpace}data:{id:123456}<br/>
        }).then(res=>{<br/>
        ${htmlSpace}console.log(res)<br/>
        })`,
          `<br/>async function query(){<br/>
        ${htmlSpace}const res = await net.custom({<br/>
        ${htmlSpace}${htmlSpace}url:'https://examples/example.html',<br/>
        ${htmlSpace}${htmlSpace}method:'POST',<br/>
        ${htmlSpace}${htmlSpace}data:{id:123456}})<br/>
        ${htmlSpace}console.log(res)<br/>
        }`
        ]
      },
      {
        name: 'setPort',
        describe: '设置端口，跟在基地址与二层地址之后',
        parameter: [
          {
            name: 'port',
            type: 'Number | String',
            describe: '端口号'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: ['const net = new Net()', 'net.setPort(25565)']
      },
      {
        name: 'setHeaders',
        describe: '设置全局请求头',
        parameter: [
          {
            name: 'headers',
            type: 'Object',
            describe: '请求头'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: [
          'const net = new Net()',
          'net.setHeaders({cusTest:1234456})'
        ]
      },
      {
        name: 'closeRequestInterceptor',
        describe: '关闭请求拦截器',
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: [
          'const net = new Net()',
          'net.closeRequestInterceptor()'
        ]
      },
      {
        name: 'closeResponseInterceptor',
        describe: '关闭响应拦截器',
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: [
          'const net = new Net()',
          'net.closeResponseInterceptor()'
        ]
      },
      {
        name: 'Interceptor.request',
        describe: '设置请求拦截器',
        parameter: [
          {
            name: 'reqFn',
            type: 'Function',
            describe: '成功||开始的回调'
          },
          {
            name: 'errFn',
            type: 'Function',
            describe: '失败的回调'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: [
          'const net = new Net()',
          'function fn1(res){console.log(res)}',
          'function fn2(err){console.log(err)}',
          'net.Interceptor.request(fn1,fn2)'
        ]
      },
      {
        name: 'Interceptor.response',
        describe: '设置响应拦截器',
        parameter: [
          {
            name: 'reqFn',
            type: 'Function',
            describe: '成功||开始的回调'
          },
          {
            name: 'errFn',
            type: 'Function',
            describe: '失败的回调'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        example: [
          'const net = new Net()',
          'function fn1(res){console.log(res)}',
          'function fn2(err){console.log(err)}',
          'net.Interceptor.response(fn1,fn2)'
        ]
      }
    ]
  },
  {
    id: '12',
    name: 'Modal',
    type: 'Object',
    typeText: '对象',
    describe: '浮窗类',
    data: [
      {
        name: 'question',
        describe: '选择型浮窗，具有确定与取消按钮，出现时背景黑幕',
        parameter: [
          {
            name: 'title',
            type: 'String',
            describe: '显示标题',
            default: "''"
          },
          {
            name: 'content',
            type: 'String',
            describe: '显示内容',
            default: "''"
          },
          {
            name: 'sureFunction',
            type: 'Function',
            describe: '确认按钮执行函数'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        callback: [
          {
            name: 'sureFunction',
            describe: '用户按下确认按钮时执行的函数'
          }
        ],
        example: [
          "Modal.question('标题','内容',()=>{console.log(yes')})"
        ]
      },
      {
        name: 'prompt',
        describe: '提示型浮窗，具有确定按钮，出现时背景黑幕',
        parameter: [
          {
            name: 'title',
            type: 'String',
            describe: '显示标题',
            default: "''"
          },
          {
            name: 'content',
            type: 'String',
            describe: '显示内容',
            default: "''"
          },
          {
            name: 'sureFunction',
            type: 'Function',
            describe: '确认按钮执行函数'
          }
        ],
        return: [
          {
            type: 'undefined',
            describe: ''
          }
        ],
        callback: [
          {
            name: 'sureFunction',
            describe: '用户按下确认按钮时执行的函数'
          }
        ],
        example: [
          "Modal.prompt('标题','内容',()=>{console.log(yes')})"
        ]
      },
      {
        name: 'prompt',
        describe: '轻提示浮窗。',
        parameter: [
          {
            name: 'content',
            type: 'String',
            describe: '显示内容',
            default: "''"
          },
          {
            name: 'position',
            type: 'String',
            describe:
              '显示位置。可选位置：top、center、bottom。空输入或者非指定关键词时，默认top。',
            default: "'top'"
          },
          {
            name: 'backgroundColor',
            type: 'String',
            describe: '背景颜色',
            default: "'rgba(0,0,0,0.7)'"
          },
          {
            name: 'textColor',
            type: 'String',
            describe: '文字颜色',
            default: "'#fff'"
          }
        ],
        return: [
          {
            type: 'element',
            describe: '返回模态框自身元素'
          }
        ],
        example: ["Modal.toast('内容','center','green','red')"]
      },
      {
        name: 'custom',
        describe: '自定义浮窗，需要具有关闭元素，出现时背景黑幕',
        parameter: [
          {
            name: 'element',
            type: 'String | element',
            describe: '需要显示的父元素或css选择器'
          },
          {
            name: 'moveElement',
            type: 'String | array',
            describe: '点击让父元素关闭的元素或元素数组'
          },
          {
            name: 'closeFromMask',
            type: 'Boolean',
            describe: '是否点击黑幕可以关闭元素',
            default: 'true'
          }
        ],
        return: [
          {
            type: 'Object',
            describe:
              '返回对象，目的为其中的close方法可以直接关闭当前模态框'
          }
        ],
        example: [
          "const mod = Modal.custom('.box','.close','false')",
          'mod.close()'
        ]
      }
    ]
  },
  {
    id: '13',
    name: 'form',
    type: 'Object',
    typeText: '对象',
    describe: 'form表单类',
    data: [
      {
        name: 'HTML',
        describe:
          '根据传入元素，整理表单全部value、值或选择情况，并执行回调函数。',
        parameter: [
          {
            name: 'element',
            type: 'String | Element',
            describe: '表单区域父元素'
          },
          {
            name: 'submitFunction',
            type: 'Function',
            describe: '提交按钮执行函数'
          }
        ],
        return: [
          {
            type: 'undefined'
          }
        ],
        callback: [
          {
            name: 'submitFunction',
            describe: '提交行为触发时执行的函数'
          }
        ],
        callbackParameter: [
          {
            name: 'value',
            from: 'submitFunction',
            type: 'Object',
            describe:
              '表单全部值的对象。<br/>第一层是标签的type属性或者标签名，用来区分不同类型表单元素。<br/>第二层为给类型的下的元素包含的值，属性名为name属性的值，没有name会设置为id名，没有id名的，会将标签名按顺序作为属性名'
          },
          {
            name: 'item',
            from: 'submitFunction',
            type: 'Element',
            describe: '表单父元素'
          }
        ],
        example: ["form.HTML('.formDiv',value=>{console.log(value)})"]
      },
      {
        name: 'getValue',
        describe:
          '根据传入元素，整理表单全部value、值或选择情况，并返回表单数据',
        parameter: [
          {
            name: 'element',
            type: 'String | Element',
            describe: '表单区域父元素'
          }
        ],
        return: [
          {
            type: 'Object',
            describe:
              '当表单提交动作触发时，直接返回全部表单元素的数据。<br/>第一层是标签的type属性或者标签名，用来区分不同类型表单元素。<br/>第二层为给类型的下的元素包含的值，属性名为name属性的值，没有name会设置为id名，没有id名的，会将标签名按顺序作为属性名'
          }
        ],
        example: ["const data = form.getValue('.formDiv')"]
      },
      {
        name: 'require',
        describe:
          '根据传入元素，整理表单全部value、值或选择情况，会对空内容进行标红处理，并执行回调函数。',
        parameter: [
          {
            name: 'element',
            type: 'String | Element',
            describe: '表单区域父元素'
          },
          {
            name: 'admitEmpty',
            type: 'Boolean',
            describe: `是否开启空内容检测。<br>设置为true开启此项后，会判断该表单中的全部空内容元素。<br>可以在回调函数的第二个参数接收布尔值，进行判断，如果此项为false，回调函数的第二个参数则永远为false。<br>此项对于selected下拉框，则认为value等于第一个选项的value时为空。<br>
            此项开启还会让表单发生提交行为时，所有的空内容元素的样式具有红色边框与红色背景色。不为空时移除此样式。`
          },
          {
            name: 'detail',
            type: 'Array',
            describe: `表单元素内容详细判断<br>
            格式如下：<br>此数组中的每一个对象，代表一个具体的表单元素<br>
            [<br>
            ${htmlSpace}{<br>
            ${htmlSpace}${htmlSpace}//class，name，id 三选一进行定位<br/>
            ${htmlSpace}${htmlSpace}//如果全写，则仅仅只匹配第一个符合的元素<br>
            ${htmlSpace}${htmlSpace}name:"",<br>
            ${htmlSpace}${htmlSpace}class:"",<br>
            ${htmlSpace}${htmlSpace}id:"",<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//开启为空判断<br>
            ${htmlSpace}${htmlSpace}empty:true,<br>
            ${htmlSpace}${htmlSpace}//空值时执行函数<br>
            ${htmlSpace}${htmlSpace}toEmpty:function (){},<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//长度限定<br>
            ${htmlSpace}${htmlSpace}length:[6,30],<br>
            ${htmlSpace}${htmlSpace}//长度不符执行函数<br>
            ${htmlSpace}${htmlSpace}toLength:function (){},<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//正则限定<br>
            ${htmlSpace}${htmlSpace}reg:"",<br>
            ${htmlSpace}${htmlSpace}//正则不符执行函数<br>
            ${htmlSpace}${htmlSpace}toReg:function (){},<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//以上判断有任意一个不成功的执行函数<br>
            ${htmlSpace}${htmlSpace}to:function (){}<br>
            ${htmlSpace}}<br>
            ]
            `
          },
          {
            name: 'submitFunction',
            type: 'Function',
            describe: '表单提交动作执行函数'
          }
        ],
        callback: [
          {
            name: 'submitFunction',
            describe: '提交行为触发时执行的函数'
          }
        ],
        callbackParameter: [
          {
            name: 'value',
            from: 'submitFunction',
            type: 'Object',
            describe:
              '表单全部值的对象。<br/>第一层是标签的type属性或者标签名，用来区分不同类型表单元素。<br/>第二层为给类型的下的元素包含的值，属性名为name属性的值，没有name会设置为id名，没有id名的，会将标签名按顺序作为属性名'
          },
          {
            name: 'isEmpty',
            from: 'submitFunction',
            type: 'Boolean',
            describe: '当设置了第二个参数admitEmpty时，此项生效，否则永远为false。用来判断是否全部元素都不为空。全部不为空，值为true。有任意一个为空为false'
          },
          {
            name: 'isDetail',
            from: 'submitFunction',
            type: 'Boolean',
            describe: '此项会判断是否所有元素都满足了在第三个参数detail中设置的全部条件。全满足为true，任意不满足，则为false'
          },
          {
            name: 'item',
            from: 'submitFunction',
            type: 'element',
            describe: '此项为表单的父元素，即此方法最开始的参数所代表的元素'
          }
        ],
        return: [
          {
            type: 'undefined'
          }
        ],
        example: [`
        form.require('.formDiv',true,[{<br>
        ${htmlSpace}id:"userName",<br>
        ${htmlSpace}length:[6,30],<br>
        ${htmlSpace}toLength:() => {console.log("您的输入长度不符")}<br>
        }],(data,isEmpty ,isDetail ,item)=>{<br>
        ${htmlSpace}console.log(data)<br>
        ${htmlSpace}console.log(isEmpty)<br>
        ${htmlSpace}console.log(isDetail)<br>
        ${htmlSpace}console.log(item)<br>
        })`]
      },
      {
        name: 'getValueRequire',
        describe:
          '根据传入元素，整理表单全部value、值或选择情况，会对空内容进行标红处理，并返回表单数据',
        parameter: [
          {
            name: 'element',
            type: 'String | Element',
            describe: '表单区域父元素'
          },
          {
            name: 'admitEmpty',
            type: 'Boolean',
            describe: `是否开启空内容检测。<br>设置为true开启此项后，会判断该表单中的全部空内容元素。<br>可以在回调函数的第二个参数接收布尔值，进行判断，如果此项为false，回调函数的第二个参数则永远为false。<br>此项对于selected下拉框，则认为value等于第一个选项的value时为空。<br>
            此项开启还会让表单发生提交行为时，所有的空内容元素的样式具有红色边框与红色背景色。不为空时移除此样式。`
          },
          {
            name: 'detail',
            type: 'Array',
            describe: `表单元素内容详细判断<br>
            格式如下：<br>此数组中的每一个对象，代表一个具体的表单元素<br>
            [<br>
            ${htmlSpace}{<br>
            ${htmlSpace}${htmlSpace}//class，name，id 三选一进行定位<br/>
            ${htmlSpace}${htmlSpace}//如果全写，则仅仅只匹配第一个符合的元素<br>
            ${htmlSpace}${htmlSpace}name:"",<br>
            ${htmlSpace}${htmlSpace}class:"",<br>
            ${htmlSpace}${htmlSpace}id:"",<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//开启为空判断<br>
            ${htmlSpace}${htmlSpace}empty:true,<br>
            ${htmlSpace}${htmlSpace}//空值时执行函数<br>
            ${htmlSpace}${htmlSpace}toEmpty:function (){},<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//长度限定<br>
            ${htmlSpace}${htmlSpace}length:[6,30],<br>
            ${htmlSpace}${htmlSpace}//长度不符执行函数<br>
            ${htmlSpace}${htmlSpace}toLength:function (){},<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//正则限定<br>
            ${htmlSpace}${htmlSpace}reg:"",<br>
            ${htmlSpace}${htmlSpace}//正则不符执行函数<br>
            ${htmlSpace}${htmlSpace}toReg:function (){},<br>
            ${htmlSpace}${htmlSpace}<br>
            ${htmlSpace}${htmlSpace}//以上判断有任意一个不成功的执行函数<br>
            ${htmlSpace}${htmlSpace}to:function (){}<br>
            ${htmlSpace}}<br>
            ]
            `
          }
        ],
        return: [
          {
            type: 'Object',
            describe: `数据与判断的全部结果：<br>
            {<br>
            ${htmlSpace}data,//全部数据<br>
            ${htmlSpace}isEmpty,//是否有空值<br>
            ${htmlSpace}isDetail//是否全部符合自定义判断<br>
            }`
          }
        ],
        example: [`
        const data = form.require('.formDiv',true,[{<br>
        ${htmlSpace}id:"userName",<br>
        ${htmlSpace}length:[6,30],<br>
        ${htmlSpace}toLength:() => {console.log("您的输入长度不符")}<br>
        }]`]
      },
      {
        name: 'eye',
        describe:
          '为密码框架加上眼睛效果，并控制密码框类型变换。',
        parameter: [
          {
            name: 'element',
            type: 'input-password-Element',
            describe: '密码框元素'
          },
          {
            name: 'iconFontClose',
            type: 'String',
            describe: `可选，闭眼字体图标的class类名`
          },
          {
            name: 'iconFontOpen',
            type: 'String',
            describe: `可选，睁眼字体图标的class类名`
          }
        ],
        return: [
          {
            type: 'Element',
            describe: `返回眼睛元素`
          }
        ],
        example: [`form.eye(".userPassword")`]
      },
      {
        name: 'textareaLength',
        describe:
          '为多行文本加上字数显示与限制字数。<br>textarea元素未获得焦点则隐藏，获得焦点则显示。<br>达到限定字数时会无法输入，并将字数元素的颜色变为绿色。<br>已对输入法状态做出判断，防止最后一位字符位中文时输入不进去。',
        parameter: [
          {
            name: 'element',
            type: 'textarea-Element',
            describe: '多行文本元素'
          },
          {
            name: 'length',
            type: 'Number',
            describe: `限定字数`,
            default:20
          }
        ],
        return: [
          {
            type: 'Element',
            describe: `返回字数控制元素`
          }
        ],
        example: [`form.textareaLength(".textareaInfo")`]
      },
      {
        name: 'inputLength',
        describe:
          '为input加上字数显示与限制字数。<br>input元素未获得焦点则隐藏，获得焦点则显示。<br>达到限定字数时会无法输入，并将字数元素的颜色变为绿色。<br>已对输入法状态做出判断，防止最后一位字符位中文时输入不进去。',
        parameter: [
          {
            name: 'element',
            type: 'input-Element',
            describe: 'input输入框元素'
          },
          {
            name: 'length',
            type: 'Number',
            describe: `限定字数`,
            default:20
          }
        ],
        return: [
          {
            type: 'Element',
            describe: `返回字数控制元素`
          }
        ],
        example: [`form.inputLength(".inputInfo")`]
      },
      {
        name: 'inputSelect',
        describe:
          '为input输入框加上下拉选项，右侧具有三角形元素，获得焦点时出现下拉框，具有模糊匹配更新下拉列表的功能，失去焦点隐藏下拉框',
        parameter: [
          {
            name: 'element',
            type: 'input-Element',
            describe: 'input输入框元素'
          },
          {
            name: 'data',
            type: 'Array | Object',
            describe: `选项数组`
          },
          {
            name: 'notFound',
            type: 'String',
            describe: `输入值没有模糊匹配到data数组里的数据时显示的文字`,
            default:"'暂无数据'"
          },
          {
            name: 'limitation',
            type: 'Boolean',
            describe: `是否限制输入框必须模糊匹配数据，不匹配则在输入框失去焦点后清空输入框`
          },
          {
            name: 'callback',
            type: 'Function',
            describe: `回调函数，用来获取点击之后的值`
          }
        ],callback: [
        {
          name: "callback",
          describe: "用户点击下拉框之后的操作"
        }
      ],
      callbackParameter: [
        {
          name: "value",
          from: "callback",
          type: "String",
          describe: "用户点击下拉框后，返回参数data数组的索引，或者参数data对象的key"
        }
      ],
        return: [
          {
            type: 'Element',
            describe: `返回下拉三角形图形元素`
          }
        ],
        example: [`form.inputSelect(".inputInfo",[1,2,3,4],'无数据',true,data=>{console.log(data)})`]
      }
    ]
  },
  {
  id: "14", name: "css", type: "Object", typeText: "对象", describe: "css样式类",
  data: [
    {
      name: "style",describe: "单个元素的样式设置",
      parameter: [
        {
          name: "element",
          type: "Element",
          describe: "CSS选择器或元素"
        },
        {
          name: "styleList",
          type: "Object",
          describe: "样式对象"
        }
      ],
      return: [
        {
          type: "element",
          describe: "返回第一个参数所代表的元素"
        }
      ],
      example: [
        `css.style('.box',{<br>
        ${htmlSpace}backgroundColor:"red",<br>
        ${htmlSpace}height:"100px",<br>
        ${htmlSpace}width:"100px"<br>
        })`
      ]
    },
    {
      name: "styles",describe: "多个同名元素的样式设置",
      parameter: [
        {
          name: "elements",
          type: "Element",
          describe: "CSS选择器或元素伪数组"
        },
        {
          name: "styleList",
          type: "Object",
          describe: "样式对象"
        }
      ],
      return: [
        {
          type: "NodeList",
          describe: "返回第一个参数所代表的元素伪数组"
        }
      ],
      example: [
        `css.styles('.publicBox',{<br>
        ${htmlSpace}backgroundColor:"red",<br>
        ${htmlSpace}height:"100px",<br>
        ${htmlSpace}width:"100px"<br>
        })`
      ]
    },
    {
      name: "scrollbar",describe: "滚动条自定义CSS样式",
      parameter: [
        {
          name: "element",
          type: "String",
          describe: "需要定义自身内部滚动条样式的元素",
          default:"body"
        },
        {
          name: "style",
          type: "Object",
          describe: `滚动条背景CSS样式<br><br>格式有要求：<br>
            { <br>
            ${htmlSpace}//对滚动条背景进行样式设置<br>
            <br>
            ${htmlSpace}track: {<br>
            ${htmlSpace}${htmlSpace}//对滚动条轨道样式进行设置<br>
            ${htmlSpace}}, <br>
            ${htmlSpace}thumb: {<br>
            ${htmlSpace}${htmlSpace}//对滚动条滑块样式进行设置<br>
            ${htmlSpace}} <br>
            }
          `
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `css.scrollbar('.scrollbarBox',{<br>
        ${htmlSpace}backgroundColor:"red",<br>
        ${htmlSpace}track: {<br>
        ${htmlSpace}${htmlSpace}backgroundColor:"blue"<br>
        ${htmlSpace}}, <br>
        ${htmlSpace}thumb: {<br>
        ${htmlSpace}${htmlSpace}backgroundColor:"green"<br>
        ${htmlSpace}} <br>
        })`
      ]
    },
    {
      name: "base",describe: "css全局通用样式base，内置常用的base样式，使用style标签加载在hear里。并对所有的a标签的href属性都加上 javascript:; 值",
      parameter: [
        {
          name: "themeFontColors",
          type: "String",
          describe: "全局字体颜色",
          default:"#333"
        },
        {
          name: "themeFontWeight",
          type: "String",
          describe: "全局字体大小",
          default:"14px"
        },
        {
          name: "bodyBackground",
          type: "String",
          describe: "body背景颜色",
          default:"#fff"
        },
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `css.base()`
      ]
    }
  ]},
  {
  id: "15", name: "事件绑定", type: "Function", typeText: "函数", describe: "对元素的事件绑定进行封装",
  data: [
    {
      name: "Listener",describe: "单元素单事件绑定的简写形式",
      parameter: [
        {
          name: "element",
          type: "Element",
          describe: "绑定元素或其选择器"
        },
        {
          name: "listener",
          type: "String",
          describe: `事件类型<br>
            写法一：直接写事件名<br>
            ${htmlSpace}例如：click<br>
            写法二：写触发对象<br>
            ${htmlSpace}例如：<br>
            ${htmlSpace}{keydown:"13"}<br>
            ${htmlSpace}{keydown:"Enter"}<br>
            ${htmlSpace}{keydown:"NumpadEnter"}<br>
            ${htmlSpace}{mousedown:"1"}<br>
            <br>
            对象封装的键盘检测有：keyCode、code、key<br>
            对象封装的鼠标检测有：button、buttons<br>
            其他无封装，请在回调函数中利用第二个参数事件源 event 自行处理<br>
            <br>
          `
        },
        {
          name: "executeFunction",
          type: "Function",
          describe: "执行函数"
        },
      ],
      return: [
        {
          type: "undefined"
        }
      ],callback: [
        {
          name: "executeFunction",
          describe: "事件触发的执行函数"
        }
      ],
      callbackParameter: [
        {
          name: "element",
          from: "executeFunction",
          type: "Element",
          describe: "元素对象本身"
        },
        {
          name: "event",
          from: "executeFunction",
          type: "Object",
          describe: "事件源"
        },
      ],
      example: [
        `Listener(".testButton","click",(ele,event)=>{<br>
        ${htmlSpace}console.log("点击了")<br>
        ${htmlSpace}console.log(ele)<br>
        ${htmlSpace}console.log(event)<br>
        })`
      ]
    },
    {
      name: "Listeners",describe: "单元素多事件绑定，执行同样的代码时使用",
      parameter: [
        {
          name: "element",
          type: "Element",
          describe: "绑定元素或其选择器"
        },
        {
          name: "listeners",
          type: "Array",
          describe: `事件类型数组<br>
            写法一：直接写事件名<br>
            ${htmlSpace}例如：['click', 'keydown']<br>
            写法二：写触发对象<br>
            ${htmlSpace}例如：<br>
            ${htmlSpace}['click', {keydown:"13"}]<br>
            ${htmlSpace}['click', {keydown:"Enter"}]<br>
            ${htmlSpace}['click', {keydown:"NumpadEnter"}]<br>
            ${htmlSpace}['click', {mousedown:"1"}]<br>
            <br>
            对象封装的键盘检测有：keyCode、code、key<br>
            对象封装的鼠标检测有：button、buttons<br>
            其他无封装，请在回调函数中利用第二个参数事件源 event 自行处理<br>
            <br>
          `
        },
        {
          name: "executeFunction",
          type: "Function",
          describe: "执行函数"
        },
      ],
      return: [
        {
          type: "undefined"
        }
      ],callback: [
        {
          name: "executeFunction",
          describe: "事件触发的执行函数"
        }
      ],
      callbackParameter: [
        {
          name: "element",
          from: "executeFunction",
          type: "Element",
          describe: "元素对象本身"
        },
        {
          name: "event",
          from: "executeFunction",
          type: "Object",
          describe: "事件源"
        },
      ],
      example: [
        `Listeners(".testButton",['click', 'keydown'],(ele,event)=>{<br>
        ${htmlSpace}console.log("点击了")<br>
        ${htmlSpace}console.log(ele)<br>
        ${htmlSpace}console.log(event)<br>
        })`
      ]
    },
    {
      name: "AllListener",describe: "全部同名元素单事件绑定，执行同样的代码时使用",
      parameter: [
        {
          name: "elements",
          type: "Element",
          describe: "绑定元素伪数组或其选择器"
        },
        {
          name: "listener",
          type: "Array",
          describe: `事件类型<br>
            写法一：直接写事件名<br>
            ${htmlSpace}例如：click<br>
            写法二：写触发对象<br>
            ${htmlSpace}例如：<br>
            ${htmlSpace}{keydown:"13"}<br>
            ${htmlSpace}{keydown:"Enter"}<br>
            ${htmlSpace}{keydown:"NumpadEnter"}<br>
            ${htmlSpace}{mousedown:"1"}<br>
            <br>
            对象封装的键盘检测有：keyCode、code、key<br>
            对象封装的鼠标检测有：button、buttons<br>
            其他无封装，请在回调函数中利用第二个参数事件源 event 自行处理<br>
            <br>
          `
        },
        {
          name: "executeFunction",
          type: "Function",
          describe: "执行函数"
        },
      ],
      return: [
        {
          type: "undefined"
        }
      ],callback: [
        {
          name: "executeFunction",
          describe: "事件触发的执行函数"
        }
      ],
      callbackParameter: [
        {
          name: "element",
          from: "executeFunction",
          type: "Element",
          describe: "元素对象本身"
        },
        {
          name: "event",
          from: "executeFunction",
          type: "Object",
          describe: "事件源"
        },
      ],
      example: [
        `AllListener(".testButtons",'click',(ele,event)=>{<br>
        ${htmlSpace}console.log("点击了")<br>
        ${htmlSpace}console.log(ele)<br>
        ${htmlSpace}console.log(event)<br>
        })`
      ]
    },
    {
      name: "eventsListener",describe: "多元素单事件绑定，执行同样的代码时使用",
      parameter: [
        {
          name: "elements",
          type: "Array",
          describe: "绑定元素数组或其选择器数组"
        },
        {
          name: "listener",
          type: "Array",
          describe: `事件类型<br>
            写法一：直接写事件名<br>
            ${htmlSpace}例如：click<br>
            写法二：写触发对象<br>
            ${htmlSpace}例如：<br>
            ${htmlSpace}{keydown:"13"}<br>
            ${htmlSpace}{keydown:"Enter"}<br>
            ${htmlSpace}{keydown:"NumpadEnter"}<br>
            ${htmlSpace}{mousedown:"1"}<br>
            <br>
            对象封装的键盘检测有：keyCode、code、key<br>
            对象封装的鼠标检测有：button、buttons<br>
            其他无封装，请在回调函数中利用第二个参数事件源 event 自行处理<br>
            <br>
          `
        },
        {
          name: "executeFunction",
          type: "Function",
          describe: "执行函数"
        },
      ],
      return: [
        {
          type: "undefined"
        }
      ],callback: [
        {
          name: "executeFunction",
          describe: "事件触发的执行函数"
        }
      ],
      callbackParameter: [
        {
          name: "element",
          from: "executeFunction",
          type: "Element",
          describe: "元素对象本身"
        },
        {
          name: "event",
          from: "executeFunction",
          type: "Object",
          describe: "事件源"
        },
      ],
      example: [
        `eventsListener(".testButtons",'click',(ele,event)=>{<br>
        ${htmlSpace}console.log("点击了")<br>
        ${htmlSpace}console.log(ele)<br>
        ${htmlSpace}console.log(event)<br>
        })`
      ]
    },
  ]},
  {
  id: "16", name: "renderContent", type: "Function", typeText: "函数", describe: "元素内容渲染，采用innerHTML方法",
  data: [
    {
      parameter: [
        {
          name: "element",
          type: "Element",
          describe: "需要渲染内容的元素或者css选择器"
        },
        {
          name: "content",
          type: "String",
          describe: "渲染内容"
        },
        {
          name: "cover",
          type: "Boolean",
          describe: "是否覆盖渲染，设为true后会覆盖掉原内容进行渲染"
        },
      ],
      return: [
        {
          type: "String",
          describe: "元素渲染的innerHTML内容"
        }
      ],
      example: [
        `renderContent(".box","<p>测试内容</p>",true)`
      ]
    }
  ]},
  {
    id: "17", name: "singleLayer", type: "Function", typeText: "函数", describe: `将多层嵌套的对象拆分成一层结构。<br>其中，如果出现同名属性会自动在末尾加上序号排序。<br>例如：<br>{<br>
      a:{c:123},<br>
      b:{c:123},<br>
      c:{c:123}<br>
    }<br>
    会拆分成：<br>
    {<br>
      c:123<br>
      c_2:123<br>
      c_3:123<br>
    }<br>
    之所以加上 _ 来分割，是为了万一原属性名末尾也是数字，且同名数量达到了至少两位数，后续可能会不好做切割分离`,
  data: [
    {
      parameter: [
        {
          name: "obj",
          type: "Object",
          describe: "具有多层结构的对象",
          default:"{}"
        }
      ],
      return: [
        {
          type: "Object",
          describe: "返回单层结构的对象"
        }
      ],
      example: [
        `const example = { a: { c: 123 }, b: { c: 123 },c: { c: 123 } }<br>
        console.log(singleLayer(example));`
      ]
    }
  ]},
  {
  id: "18", name: "local", type: "Object", typeText: "对象", describe: "本地持久化存储方法，对原生localStorage方法进行封装，会自动进行JSON转换",
  data: [
    {
      name: "set",describe: "将数据存储到本地，会将数据自动进行JSON格式处理",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "data",
          type: "String",
          describe: "属性值"
        },
      ],
      return: [
        {
          type: "JSON | null",
          describe: "返回处理好的JSON数据或者null"
        }
      ],
      example: [
        `local.set("num",123)`
      ]
    },
    {
      name: "get",describe: "获取数据到本地，可传入执行函数直接处理",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "processingData",
          type: "Function",
          describe: "可选，获取数据成功后执行的函数"
        },
      ],
      return: [
        {
          type: "data | null",
          describe: "返回处理好的数据或者null"
        }
      ],callback: [
        {
          name: "processingData",
          describe: "获取数据成功后执行的函数"
        }
      ],
      callbackParameter: [
        {
          name: "data",
          from: "processingData",
          type: "any",
          describe: "从本地获取的数据，已对其进行了JSON还原处理，可以直接使用"
        }
      ],
      example: [
        `local.get("num",data=>{console.log(data)})`
      ]
    },
    {
      name: "remove",describe: "删除指定的本地数据",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "errInfo",
          type: "Boolean",
          describe: "是否显示未找到数据的错误提示，当未找到数据时，会使用console.error抛出异常",
          default:true
        },
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否成功删除数据"
        }
      ],
      example: [
        `local.remove("num")`
      ]
    },
    {
      name: "clear",describe: "清空本地存储数据",
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `local.clear()`
      ]
    },
    {
      name: "setMagicString",describe: "设置魔法字符串，此项设置后，其他方法可以直接被无参数调用或者忽略第一个参数，直接传入第二个参数。",
      parameter: [
        {
          name: "str",
          type: "String",
          describe: "设置魔法字符串代表的属性名",
          default:"''"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `local.setMagicString("token")`
      ]
    },
  ]},
  {
  id: "19", name: "session", type: "Object", typeText: "对象", describe: "本地临时存储方法，对原生sessionStorage方法进行封装，会自动进行JSON转换",
  data: [
    {
      name: "set",describe: "将数据存储到本地，会将数据自动进行JSON格式处理",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "data",
          type: "String",
          describe: "属性值"
        },
      ],
      return: [
        {
          type: "JSON | null",
          describe: "返回处理好的JSON数据或者null"
        }
      ],
      example: [
        `session.set("num",123)`
      ]
    },
    {
      name: "get",describe: "获取数据到本地，可传入执行函数直接处理",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "processingData",
          type: "Function",
          describe: "可选，获取数据成功后执行的函数"
        },
      ],
      return: [
        {
          type: "data | null",
          describe: "返回处理好的数据或者null"
        }
      ],callback: [
        {
          name: "processingData",
          describe: "获取数据成功后执行的函数"
        }
      ],
      callbackParameter: [
        {
          name: "data",
          from: "processingData",
          type: "any",
          describe: "从本地获取的数据，已对其进行了JSON还原处理，可以直接使用"
        }
      ],
      example: [
        `session.get("num",data=>{console.log(data)})`
      ]
    },
    {
      name: "remove",describe: "删除指定的本地数据",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "errInfo",
          type: "Boolean",
          describe: "是否显示未找到数据的错误提示，当未找到数据时，会使用console.error抛出异常",
          default:true
        },
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否成功删除数据"
        }
      ],
      example: [
        `session.remove("num")`
      ]
    },
    {
      name: "clear",describe: "清空本地存储数据",
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `session.clear()`
      ]
    },
    {
      name: "setMagicString",describe: "设置魔法字符串，此项设置后，其他方法可以直接被无参数调用或者忽略第一个参数，直接传入第二个参数。",
      parameter: [
        {
          name: "str",
          type: "String",
          describe: "设置魔法字符串代表的属性名",
          default:"''"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `session.setMagicString("token")`
      ]
    },
  ]},
  {
  id: "20", name: "cookie", type: "Object", typeText: "对象", describe: "本地cookie存储方法，对原生document.cookie方法进行封装",
  data: [
    {
      name: "set",describe: "将数据存储到本地",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "data",
          type: "String",
          describe: "属性值"
        },
      ],
      return: [
        {
          type: "Object",
          describe: "返回对象，将传入的数据包装成对象"
        }
      ],
      example: [
        `cookie.set("num",123)`
      ]
    },
    {
      name: "get",describe: "获取数据到本地，自动处理为对象",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "可选，属性名。不写则返回全部cookie对象",
          default:"''"
        }
      ],
      return: [
        {
          type: "data | null",
          describe: "返回处理好的数据对象或者null"
        }
      ],
      example: [
        `const data = cookie.get("num")`
      ]
    },
    {
      name: "remove",describe: "删除指定的本地cookie数据",
      parameter: [
        {
          name: "dataName",
          type: "String",
          describe: "属性名",
          default:"''"
        },
        {
          name: "errInfo",
          type: "Boolean",
          describe: "是否显示未找到数据的错误提示，当未找到数据时，会使用console.error抛出异常",
          default:true
        },
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否成功删除数据"
        }
      ],
      example: [
        `cookie.remove("num")`
      ]
    },
    {
      name: "clear",describe: "清空本地cookie存储数据",
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `cookie.clear()`
      ]
    },
    {
      name: "setMagicString",describe: "设置魔法字符串，此项设置后，其他方法可以直接被无参数调用或者忽略第一个参数，直接传入第二个参数。",
      parameter: [
        {
          name: "str",
          type: "String",
          describe: "设置魔法字符串代表的属性名",
          default:"''"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `cookie.setMagicString("token")`
      ]
    },
  ]},
  {
  id: "21", name: "toUrl", type: "Function", typeText: "函数", describe: "跳转至目标URL，属于对原生location.href的简写封装",
  data: [
    {
      parameter: [
        {
          name: "url",
          type: "String",
          describe: "需要跳转的目标地址",
          default:"''"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `toUrl('https://www.baidu.com/')`
      ]
    }
  ]},
  {
  id: "22", name: "MapTable", type: "Constructor", typeText: "构造函数", describe: "映射表构造函数。<br>用来创建一个映射表，并利用其中封装的方法进行快速调用、匹配与查询",
  data: [
    {
      parameter: [
        {
          name: "Table",
          type: "Object",
          describe: "实例化MapTable时，传入一个对象，里面为初始构建起来的自定义映射表。<br>后续可以对其再添加或者其他管理<br><br>需要获取现有映射表时，使用 .Table 即可获取到映射表对象。见示例",
          default:"{}"
        }
      ],
      example: [
        `const map = new MapTable({<br>
        ${htmlSpace}a:1,<br>
        ${htmlSpace}b:"2",<br>
        ${htmlSpace}3:"c",<br>
        ${htmlSpace}d:4.5<br>
        })<br>
        console.log(map.Table)//获取具体的映射表对象
        `
      ]
    },
    {
      name: "seek",describe: "查询映射表中是否存在某个key/value,此方法会判断映射表中的全部属性名与属性值，是否存在某个指定的数据",
      parameter: [
        {
          name: "anyKey",
          type: "any",
          describe: "任意值，用来寻找属性名或者属性值是否存在在映射表中"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "返回是否存在"
        }
      ],
      example: [
        `const map = new MapTable({<br>
        ${htmlSpace}a:1,<br>
        ${htmlSpace}b:"2",<br>
        ${htmlSpace}3:"c",<br>
        ${htmlSpace}d:4.5<br>
        })<br>
        console.log(map.seek("3"))<br>
        console.log(map.seek("2"))
        `
      ]
    },
    {
      name: "seekKey",describe: "查询映射表中是否存在某个key,此方法只会判断映射表中的全部属性名，是否存在某个指定的数据。而不会寻找属性值",
      parameter: [
        {
          name: "anyKey",
          type: "any",
          describe: "任意值，用来寻找某个属性名是否存在在映射表中"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "返回是否存在"
        }
      ],
      example: [
        `const map = new MapTable({<br>
        ${htmlSpace}a:1,<br>
        ${htmlSpace}b:"2",<br>
        ${htmlSpace}3:"c",<br>
        ${htmlSpace}d:4.5<br>
        })<br>
        console.log(map.seekKey("3"))<br>
        console.log(map.seekKey("2"))
        `
      ]
    },
    {
      name: "seekValue",describe: "查询映射表中是否存在某个value,此方法只会判断映射表中的全部属性值，是否存在某个指定的数据。而不会寻找属性名",
      parameter: [
        {
          name: "anyKey",
          type: "any",
          describe: "任意值，用来寻找某个属性值是否存在在映射表中"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "返回是否存在"
        }
      ],
      example: [
        `const map = new MapTable({<br>
        ${htmlSpace}a:1,<br>
        ${htmlSpace}b:"2",<br>
        ${htmlSpace}3:"c",<br>
        ${htmlSpace}d:4.5<br>
        })<br>
        console.log(map.seekValue("3"))<br>
        console.log(map.seekValue("2"))
        `
      ]
    },
    {
      name: "mapping",describe: "主要功能，查找并返回映射表的对应key/value",
      parameter: [
        {
          name: "anyKey",
          type: "any",
          describe: "任意值，用来寻找某个属性名对应的属性值，或者寻找属性值对性的属性名。双向查找，只要映射表中存在，则返回他的对应数据。多个同名属性，只会返回第一个"
        }
      ],
      return: [
        {
          type: "any | undefined",
          describe: "返回寻找到的key/value，未找到则返回undefined"
        }
      ],
      example: [
        `const map = new MapTable({<br>
        ${htmlSpace}a:1,<br>
        ${htmlSpace}b:"2",<br>
        ${htmlSpace}3:"c",<br>
        ${htmlSpace}d:4.5<br>
        })<br>
        console.log(map.mapping("3"))<br>
        console.log(map.mapping("2"))
        `
      ]
    },
    {
      name: "add",describe: "往映射表中添加键值对",
      parameter: [
        {
          name: "mapObj",
          type: "Object",
          describe: "向现有映射表中添加新的映射键值对"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `const map = new MapTable({<br>
        ${htmlSpace}a:1,<br>
        ${htmlSpace}b:"2",<br>
        ${htmlSpace}3:"c",<br>
        ${htmlSpace}d:4.5<br>
        })<br>
        map.add({e:6})
        console.log(map.Table)
        `
      ]
    },
    {
      name: "del",describe: "删除映射表中的键值对，可传入key或value",
      parameter: [
        {
          name: "mapObj",
          type: "any",
          describe: "用来删除现有映射表中的键值对，可以传入属性名或者属性值，两种传参方式都会删除掉第一个匹配到的键值对"
        }
      ],
      return: [
        {
          type: "Object",
          describe: "返回删除掉的键值对"
        }
      ],
      example: [
        `const map = new MapTable({<br>
        ${htmlSpace}a:1,<br>
        ${htmlSpace}b:"2",<br>
        ${htmlSpace}3:"c",<br>
        ${htmlSpace}d:4.5<br>
        })<br>
        console.log(map.del("a"))<br>
        console.log(map.Table)
        `
      ]
    },
  ]},
  {
  id: "23", name: "randomToken", type: "Function", typeText: "函数", describe: "获取指定长度的随机字符串，包含了数字，大写与小写字母。如果第二个参数special设置为true，还会包含预设的特殊字符。",
  data: [
    {
      parameter: [
        {
          name: "length",
          type: "Number",
          describe: "随机字符串的长度",
          default:"8"
        },{
          name: "special",
          type: "Boolean",
          describe: "是否开启特殊字符。设为true后，随机字符串中会加入预设的特殊字符。",
          default:`!@%&$_#^?+-*/=.`
        },{
          name: "specialChar",
          type: "Array",
          describe: "可选，自定义特殊字符。<br>如果传入此参数，则会摒弃掉第二个参数special中的自带特殊字符，改用自定义特殊字符，无论第二个参数是否为true。<br>但如果传入空数组，并且第二个参数为true，则依然添加内置特殊字符。",
          default:"[]"
        },
      ],
      return: [
        {
          type: "String",
          describe: "返回随机字符串"
        }
      ],
      example: [
        `randomToken(16)`
      ]
    }
  ]},
  {
  id: "24", name: "charArr", type: "Object", typeText: "对象", describe: "用来储存常用字符。<br>包括大写字母、小写字母、数字、字符串数字与特殊字符<br>此对象为备用方案，用来应对未知的使用场景。",
  data: [
    {
      isVar: true,name: "Lowercase",describe: "数组，a-z小写字母"
    },
    {
      isVar: true,name: "Uppercase",describe: "数组，A-Z大写字母"
    },
    {
      isVar: true,name: "Number",describe: "数组，0-9数字"
    },
    {
      isVar: true,name: "NumberChar",describe: "数组，'0'-'9'字符串数字"
    },
    {
      isVar: true,name: "SpecialChar",describe: "数组，特殊字符：!@%&$_#^?+-*/=."
    }
    ]
  },
  {
  id: "25", name: "Module", type: "Object", typeText: "对象", describe: "模块类，此类成用来进行模块创建，包含了CSS基础样式调试台，参考styleDebugConsole",
  data: [
    {
      name: "sliding",describe: "创建一个滑块",
      parameter: [
        {
          name: "callback",
          type: "Function",
          describe: "滑块滑动时需要执行的函数",
          default:"默认值"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],callback: [
        {
          name: "callback",
          describe: "滑块滑动时需要执行的函数"
        }
      ],
      callbackParameter: [
        {
          name: "percentage ",
          from: "callback",
          type: "Number",
          describe: "滑块滑动时，将滑动百分比数字传入回调函数"
        }
      ],
      example: [
        `Module.sliding(num=>{console.log(num)})`
      ]
    },
    {
      name: "badge",describe: "创建一个徽章元素，此方法会返回元素的HTML，请使用innerHTML来将此元素加载到想要的位置",
      parameter: [
        {
          name: "leftText",
          type: "String",
          describe: "左侧文字",
          default:"''"
        },
        {
          name: "rightText",
          type: "String",
          describe: "右侧文字",
          default:"''"
        },
        {
          name: "leftColor",
          type: "String",
          describe: "左侧背景色",
          default:"#565656"
        },
        {
          name: "rightColor",
          type: "String",
          describe: "右侧背景色",
          default:"#41bc13"
        },
        {
          name: "leftTextColor",
          type: "String",
          describe: "左侧文字颜色",
          default:"#fff"
        },
        {
          name: "rightTextColor",
          type: "String",
          describe: "右侧文字颜色",
          default:"#fff"
        },
      ],
      return: [
        {
          type: "String",
          describe: "徽章元素的HTML，请利用返回值，并使用innerHTML来插入到页面中"
        }
      ],
      example: [
        `const badge = Module.badge('left','right')`
      ]
    },
    {
      name: "styleDebugConsole",describe: "CSS基础样式调试台，在页面上调出一个设置CSS样式的调试台，封装了一些常用的css样式，用来进行实时调试，以及快速获得样式的css样式文字，方便复制粘贴",
      parameter: [
        {
          name: "element",
          type: "Element",
          describe: "需要进行css样式调试的元素或元素的css选择器"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `Module.styleDebugConsole('.box')`
      ]
    }
    ]
  },
  {
  id: "26", name: "drag", type: "Function", typeText: "函数", describe: "实现元素随鼠标的拖拽而移动位置，会打破原有布局模式，使得此元素在页面上可以任意移动",
  data: [
    {
      parameter: [
        {
          name: "element",
          type: "Element",
          describe: "元素或元素的css选择器"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `drag('.box')`
      ]
    }
  ]},
  {
  id: "27", name: "Path", type: "Constructor", typeText: "构造函数", describe: "路径管理，可以管理使用的路径",
  data: [
    {
      parameter: [
        {
          name: "pathName",
          type: "Object",
          describe: "路径对象，此项进行路径配置的初始设置，后续可以添加或其他管理。当需要获取此对象时。请使用 .Path.Summary 即可获得路径对象。详见示例",
          default:"{}"
        }
      ],
      example: [
        `const path = new Path({<br>
          pa:"c:\\",<br>
          pb:"d:\\abc",<br>
          pc:"e:\\abc\\def"<br>
        })<br>
        console.log(path.Summary)
        `
      ]
    },
    {
      name: "add",describe: "增加路径",
      parameter: [
        {
          name: "name",
          type: "String",
          describe: "路径名",
          default:"''"
        },
        {
          name: "value",
          type: "String",
          describe: "具体路径",
          default:"''"
        },
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `const path = new Path({<br>
          pa:"c:\\",<br>
          pb:"d:\\abc",<br>
          pc:"e:\\abc\\def"<br>
        })<br>
        path.add("pd","f:\\")<br>
        console.log(path.Summary)
        `
      ]
    },
    {
      name: "modify",describe: "修改路径",
      parameter: [
        {
          name: "name",
          type: "String",
          describe: "需要修改的路径名",
          default:"''"
        },
        {
          name: "value",
          type: "String",
          describe: "更新后的具体路径名",
          default:"''"
        },
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `const path = new Path({<br>
          pa:"c:\\",<br>
          pb:"d:\\abc",<br>
          pc:"e:\\abc\\def"<br>
        })<br>
        path.modify("pa","f:\\")<br>
        console.log(path.Summary)
        `
      ]
    },
    {
      name: "del",describe: "删除路径",
      parameter: [
        {
          name: "name",
          type: "String",
          describe: "需要删除的路径名",
          default:"''"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `const path = new Path({<br>
          pa:"c:\\",<br>
          pb:"d:\\abc",<br>
          pc:"e:\\abc\\def"<br>
        })<br>
        path.del("pa","f:\\")<br>
        console.log(path.Summary)
        `
      ]
    },
    {
      name: "suffix",describe: "获取后缀名，默认获取对象的全部后缀名",
      parameter: [
        {
          name: "name",
          type: "String",
          describe: "需要拿取后缀名的路径名",
          default:"''"
        }
      ],
      return: [
        {
          type: "String | Object",
          describe: "返回值该路径的后缀名，或者全部路径的后缀名对象"
        }
      ],
      example: [
        `const path = new Path({<br>
          pa:"c:\\",<br>
          pb:"d:\\abc",<br>
          pc:"e:\\abc\\def"<br>
        })<br>
        console.log(path.suffix())
        `
      ]
    },
    {
      name: "setBasePath",describe: "设置公共前置路径，会添加到所有路径的前面",
      parameter: [
        {
          name: "basePath",
          type: "String",
          describe: "公共前置路径",
          default:"''"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `const path = new Path({<br>
          pa:"www.baidu.com/",<br>
          pb:"www.bilibili.com/"<br>
        })<br>
        path.setBasePath("https://")<br>
        console.log(path.Summary())
        `
      ]
    },
    {
      name: "setSecondPath",describe: "设置第二层公共前置路径，会拼接在basePath之后",
      parameter: [
        {
          name: "secondPath",
          type: "String",
          describe: "第二层公共前置路径",
          default:"''"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `const path = new Path({<br>
          pa:"baidu.com/",<br>
          pb:"bilibili.com/"<br>
        })<br>
        path.setBasePath("https://")<br>
        path.setSecondPath("www.")<br>
        console.log(path.Summary())
        `
      ]
    },
  ]},
  {
  id: "28", name: "getSuffix", type: "Function", typeText: "函数", describe: "获取路径字符串的后缀名",
  data: [
    {
      parameter: [
        {
          name: "path",
          type: "String",
          describe: "路径字符串"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `console.log(getSuffix(./a.png))`
      ]
    }
  ]},
  {
  id: "29", name: "isElementDisplay", type: "Function", typeText: "函数", describe: "判断元素是否显示在页面上，但是使用位移移动到页面外不会被检测为false",
  data: [
    {
      parameter: [
        {
          name: "element",
          type: "Element",
          describe: "css选择器或者元素"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "元素是否存在在页面上"
        }
      ],
      example: [
        `console.log(isElementDisplay(".box"))`
      ]
    }
    ]
  },
  {
  id: "30", name: "Is", type: "Object", typeText: "对象", describe: "类型判断类，用来进行各种数据类型的判断",
  data: [
    {
      name: "Number",describe: "判断数据是否为数字，包括NaN也认为是数字",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Number(123)`
      ]
    },
    {
      name: "ValidNumber",describe: "判断数据是否为非NaN的数字",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.ValidNumber(NaN)`
      ]
    },
    {
      name: "Int",describe: "判断数据是否为整数",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Int(12.5)`
      ]
    },
    {
      name: "Float",describe: "判断数据是否为浮点",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Float(12.5)`
      ]
    },
    {
      name: "Boolean",describe: "判断数据是否为布尔类型",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Boolean(false)`
      ]
    },
    {
      name: "String",describe: "判断数据是否为字符串",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.String('abc')`
      ]
    },
    {
      name: "Function",describe: "判断数据是否为函数",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Function(()=>{})`
      ]
    },
    {
      name: "Array",describe: "判断数据是否为数组",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Array([1,2,3])`
      ]
    },
    {
      name: "NodeList",describe: "判断数据是否为伪数组",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.NodeList([1,2,3])`
      ]
    },
    {
      name: "Object",describe: "判断数据是否为对象",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Object({name:'userName'})`
      ]
    },
    {
      name: "Date",describe: "判断数据是否为时间对象",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Date(new Date())`
      ]
    },
    {
      name: "Reg",describe: "判断数据是否为正则",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Reg(/^\w$/)`
      ]
    },
    {
      name: "Undefined",describe: "判断数据是否为undefined",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Undefined(undefined)`
      ]
    },
    {
      name: "Symbol",describe: "判断数据是否为Symbol",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Symbol(undefined)`
      ]
    },
    {
      name: "Element",describe: "判断数据是否为页面元素",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Element(document.querySelector('.box'))`
      ]
    },
    {
      name: "Null",describe: "判断数据是否为null",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Null(null)`
      ]
    },
    {
      name: "NaN",describe: "判断数据是否为NaN",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.NaN(NaN)`
      ]
    },
    {
      name: "JSON",describe: "判断数据是否为JSON",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.JSON('123')`
      ]
    },
    {
      name: "Promise",describe: "判断数据是否为Promise",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Promise(new Promise())`
      ]
    },
    {
      name: "Error",describe: "判断数据是否为Error",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.Error(new Error())`
      ]
    },
    {
      name: "Arguments",describe: "判断数据是否为Arguments",
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `function fn(){<br>
          Is.Arguments(arguments)<br>
        }
        `
      ]
    },
    {
      name: "EmptyObj",describe: "判断是否为空对象",
      parameter: [
        {
          name: "obj",
          type: "Object",
          describe: "需要判断的对象"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.EmptyObj({})<br>`
      ]
    },
    {
      name: "EmptyArr",describe: "判断是否为空数组",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组"
        }
      ],
      return: [
        {
          type: "Boolean",
          describe: "是否判断成功"
        }
      ],
      example: [
        `Is.EmptyArr([])<br>`
      ]
    },
  ]},
  {
  id: "31", name: "getDataType", type: "Function", typeText: "函数", describe: "获取数据类型",
  data: [
    {
      parameter: [
        {
          name: "data",
          type: "any",
          describe: "数据"
        }
      ],
      return: [
        {
          type: "String",
          describe: "返回该数据的数据类型"
        }
      ],
      example: [
        `getDataType([1,2,3])`
      ]
    }
    ]
  },
  {
  id: "32", name: "Arr", type: "Object", typeText: "对象", describe: "数组或对象数组相关方法",
  data: [
    {
      name: "getFilter",describe: "根据condition参数，来判断arr数组每一项是否满足条件",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "condition",
          type: "Object",
          describe: "判断数组中每一项是否与参数一致"
        },
        {
          name: "reverse",
          type: "Boolean",
          describe: "是否反向输出。<br>此项为true的话，返回满足条件的每一项，为false则返回不满足条件的每一项",
          default:true
        },
        {
          name: "callback",
          type: "Function",
          describe: "回调函数"
        },
      ],
      return: [
        {
          type: "Array",
          describe: "返回匹配的每一项的汇总数组"
        }
      ],callback: [
        {
          name: "callback",
          describe: "用来直接处理数据"
        }
      ],
      callbackParameter: [
        {
          name: "newArr",
          from: "callback",
          type: "Array",
          describe: "条件匹配的每一项的汇总数组"
        }
      ],
      example: [
        `const newArr = Arr.getFilter([1,2,3,4,5],"5")`
      ]
    },
    {
      name: "getFilterNum",describe: "根据condition参数，来判断arr数组满足条件的个数。属于getFilter方法的衍生方案",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "condition",
          type: "Object",
          describe: "判断数组中每一项是否与参数一致"
        },
        {
          name: "reverse",
          type: "Boolean",
          describe: "是否反向输出。<br>此项为true的话，返回满足条件的每一项，为false则返回不满足条件的每一项",
          default:true
        },
        {
          name: "callback",
          type: "Function",
          describe: "回调函数"
        },
      ],
      return: [
        {
          type: "Number",
          describe: "返回满足条件的个数"
        }
      ],
      example: [
        `const newArr = Arr.getFilterNum([1,2,3,4,5],"5")`
      ]
    },
    {
      name: "getObjFilter",describe: "根据condition对象，来判断arr数组每一项的对象是否满足条件",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "condition",
          type: "Object",
          describe: "判断对象数组中属性名指向的属性值与本condition对象的属性名指向的属性值是否一致"
        },
        {
          name: "reverse",
          type: "Boolean",
          describe: "是否反向输出。<br>此项为true的话，返回满足条件的每一项，为false则返回不满足条件的每一项",
          default:true
        },
        {
          name: "callback",
          type: "Function",
          describe: "回调函数"
        },
      ],
      return: [
        {
          type: "Array",
          describe: "返回匹配的每一项的汇总数组"
        }
      ],callback: [
        {
          name: "callback",
          describe: "用来直接处理数据"
        }
      ],
      callbackParameter: [
        {
          name: "newArr",
          from: "callback",
          type: "Array",
          describe: "条件匹配的每一项的汇总数组"
        }
      ],
      example: [
        `const newArr = Arr.getObjFilter([{a:1}，{a:2}],{a:2})`
      ]
    },
    {
      name: "getObjFilterNum",describe: "根据condition对象，来判断arr数组每一项的对象是否满足条件。<br>属于getObjFilter的衍生方法",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "condition",
          type: "Object",
          describe: "判断对象数组中属性名指向的属性值与本condition对象的属性名指向的属性值是否一致"
        },
        {
          name: "reverse",
          type: "Boolean",
          describe: "是否反向输出。<br>此项为true的话，返回满足条件的每一项，为false则返回不满足条件的每一项",
          default:true
        },
        {
          name: "callback",
          type: "Function",
          describe: "回调函数"
        },
      ],
      return: [
        {
          type: "Number",
          describe: "返回满足条件的个数"
        }
      ],
      example: [
        `const newArr = Arr.getObjFilterNum([{a:1}，{a:2}],{a:2})`
      ]
    },
    {
      name: "getObjSum",describe: "计算数组中每个对象指定值的和。<br>根据key属性名，遍历arr数组中的每一个对象，并求出该属性名对应属性值的全部和。<br>比如一个数组中很多对象都有num属性，属性值为数字，则会将所有的num属性相加",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "key",
          type: "String",
          describe: "需要求和的对象属性名"
        }
      ],
      return: [
        {
          type: "Number",
          describe: "返回计算后的和"
        }
      ],
      example: [
        `const newArr = Arr.getObjSum([{a:1}，{a:2}],"a")`
      ]
    },
    {
      name: "getObjAverage",describe: "计算数组中每个对象指定值的平均数。<br>根据key属性名，遍历arr数组中的每一个对象，并求出该属性名对应属性值的全部平均值。<br>比如一个数组中很多对象都有num属性，属性值为数字，则会将所有的num属性相加，并根据数量求出平均值",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "key",
          type: "String",
          describe: "需要求和的对象属性名"
        },
        {
          name: "places",
          type: "Number",
          describe: "需要保留的小数位数，默认显示全部"
        }
      ],
      return: [
        {
          type: "Number",
          describe: "返回计算后的平均值"
        }
      ],
      example: [
        `const newArr = Arr.getObjAverage([{a:1}，{a:2}],"a")`
      ]
    },
    {
      name: "getObjCount",describe: "在加减乘除中进行选择计算，在每个单独对象中，指定属性之间进行计算。<br>此方法不会把所有对象都统一起来汇总计算，而是单独计算每个对象中的属性值，并且返回一个数组，将每个对象的计算结果都储存起来。<br>此方法会让每个对象都独立计算，不会相互影响",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "keys",
          type: "String",
          describe: "需要被计算的对象属性名数组"
        },
        {
          name: "type",
          type: "String",
          describe: "计算类型：<br>取值有：add加法；sub减法；mul乘法；div除法",
          default:"'add'"
        }
      ],
      return: [
        {
          type: "Array",
          describe: "返回计算后数组，数组里的每一项，都是每个对象中属性的计算结果"
        }
      ],
      example: [
        `const newArr = Arr.getObjAverage([{a:1,b:3}，{a:2,b:5}],["a","b"],"add")`
      ]
    },
    {
      name: "getObjValue",describe: "寻找对象数组中每一个符合key属性的值。<br>返回新数组，每一项为对应的值",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "key",
          type: "String",
          describe: "属性名"
        }
      ],
      return: [
        {
          type: "Array",
          describe: "返回计算后数组，数组里的每一项，都是每个对象中的寻找结果"
        }
      ],
      example: [
        `const newArr = Arr.getObjValue([{a:1,b:3}，{a:2,b:5}],"b")`
      ]
    },
    {
      name: "delObjItem",describe: "根据keys的键值对，删除arr对象数组中的匹配项",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "keys",
          type: "Object",
          describe: "需要删除的对象键值对，会对所有对象进行key与value的同时匹配，全满足则认定此项匹配成功"
        },
        {
          name: "callback",
          type: "Function",
          describe: "回调函数"
        }
      ],
      return: [
        {
          type: "Array",
          describe: "返回删除后的新对象数组"
        }
      ],callback: [
        {
          name: "callback",
          describe: "回调函数"
        }
      ],
      callbackParameter: [
        {
          name: "delItem",
          from: "callback",
          type: "Array",
          describe: "此数组中包含所有被删除的对象"
        }
      ],
      example: [
        `const newArr = Arr.delObjItem([{a:1,b:3}，{a:2,b:5}],{b:5})`
      ]
    },
    {
      name: "replaceObjItem",describe: "根据KeyValuePair里面的键值对，匹配arr对象数组的每一项<br>将每一项匹配到的属性名都改为替换值",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要判断的数组",
          default:"[]"
        },
        {
          name: "keys",
          type: "Object",
          describe: "储存属性名与替换值的键值对，会将所有对象中，具有该属性名的属性值，都替换为指定的属性值<br>例如：<br>需要将所有对象中的age属性都替换为18，<br>则直接传入：{age:18}即可."
        }
      ],
      return: [
        {
          type: "Array",
          describe: "返回新对象数组"
        }
      ],
      example: [
        `const newArr = Arr.replaceObjItem([{a:1,b:3}，{a:2,b:5}],{b:7})`
      ]
    },
    {
      name: "objComputing",describe: "专门用于对对象数组进行计算的方法",
      parameter: [
        {
          name: "arr",
          type: "Array",
          describe: "需要计算的对象数组",
          default:"[]"
        },
        {
          name: "separate",
          type: "String",
          describe: `计算表达式<br>
          作用：<br>
          对单一对象里的属性，根据计算式进行计算<br>
          <br>
          格式：<br>
          使用 $$ 来包裹属性名，代表此处为对象中需要参与计算的属性。<br>
          例如： $age$<br>
          <br>
          书写计算式：<br>
          $key1$*$key2$-$key1$/$key3$<br>
          上面的key仅为举例的假定属性名。<br>
          <br>
          计算完后，是一个包含全部结果的数字数组。<br>
          会被传入回调函数的第一个参数中。<br>
          并且继续参与由下一个参数所指定的计算中<br>
          <br>
          举例：<br>
          对于对象数组：<br>
          [<br>
          ${htmlSpace}{ num: 5, age: 68, in: 6},<br>
          ${htmlSpace}{ num: 6, age: 5, in: 6},<br>
          ${htmlSpace}{ num: 7, age: 44, in: 6},<br>
          ${htmlSpace}{ num: 8, age: 55, in: 6}<br>
          ]<br>
          <br>
          进行如下计算：<br>
          $age$-18*$num$+$in$<br>
          <br>
          结果为：<br>
          [152, 107, 164, 193]<br>
          <br>
          `
        },
        {
          name: "whole",
          type: "String",
          describe: `整体操作指令<br>
          在上一个参数将每个对象进行了计算之后，再对所有计算出来的数据进行整体再计算。<br>
          <br>
          参数：<br>
          计算(返回Number)：<br>
          加法：add 或 +<br>
          减法：sub 或 -<br>
          乘法：mul 或 *<br>
          除法：div 或 /<br>
          平均数：avg<br>
          <br>
          基础筛选(返回Number)：<br>
          最大数：max<br>
          最小数：min<br>
          <br>
          比较(返回Array)：<br>
          >某个数<br>
          <某个数<br>
          >=某个数<br>
          <=某个数<br>
          ==某个数<br>
          !=某个数<br>
          ===某个数<br>
          !==某个数<br>
          <br>
          不进行操作(返回Array，也就是第二个参数计算完后的数组)：<br>
          返回数组：arr 或 []<br>
          <br>
          如果不为以上的取值，则这个方法最终会返回undefined<br>
          `,
          default:"add"
        },
        {
          name: "callback",
          type: "Function",
          describe: `回调函数`
        }
      ],callback: [
        {
          name: "callback",
          describe: "回调函数"
        }
      ],
      callbackParameter: [
        {
          name: "newArr",
          from: "callback",
          type: "Array",
          describe: `第二个参数对每个对象进行计算后的数据数组`
        }
      ],
      return: [
        {
          type: "Number | Array | undefined",
          describe: "根据第三个参数的操作方式不同，返回值也不同"
        }
      ],
      example: [
        `const tempArr = [<br>
        ${htmlSpace}{ num: 5, age: 68, in: 6},<br>
        ${htmlSpace}{ num: 6, age: 5, in: 6},<br>
        ${htmlSpace}{ num: 7, age: 44, in: 6},<br>
        ${htmlSpace}{ num: 8, age: 55, in: 6}<br>
        ]<br>
        <br>
        const newArr = Arr.objComputing(<br>
        ${htmlSpace}tempArr,<br>
        ${htmlSpace}'$age$+18*$num$-$in$',<br>
        ${htmlSpace}'-',<br>
        ${htmlSpace}res => {<br>
        ${htmlSpace}${htmlSpace}console.log(res)<br>
        ${htmlSpace}}<br>
        )<br>
        <br>
        console.log(newArr)<br>
        `
      ]
    },
    ]
  },
  {
  id: "33", name: "classExclusive", type: "Function", typeText: "函数", describe: "排他性类名添加<br>当一系列的元素，需要添加同一个类名，但是也需要做排他设计时，使用此方法",
  data: [
    {
      parameter: [
        {
          name: "eleArr",
          type: "Array | String | NodeList",
          describe: "元素伪数组或元素的css选择器或选择器数组"
        },
        {
          name: "className",
          type: "String",
          describe: "需要排它的类名"
        },
        {
          name: "listenerType",
          type: "String",
          describe: "事件类型，关于事件类型的写法，请参考事件绑定里面的写法，例如Listener方法",
          default:"click"
        }
      ],
      example: [
        `classExclusive(".boxs","active","click")`
      ]
    }
    ]
  },
  {
  id: "34", name: "parameterPassing", type: "Function", typeText: "函数", describe: "依次对传入的数组中的表达式或方法进行运算或者调用，并将计算结果或者返回值自动传入下一个方法的第一个参数，或将值传给下一个表达式中的 $val$ 表达式中。<br>可以在数组或对象中使用$val$表达式",
  data: [
    {
      parameter: [
        {
          name: "Methods_Expressions",
          type: "Array",
          describe: "方法或表达式的数组"
        },
        {
          name: "callback",
          type: "Function",
          describe: "回调函数"
        }
      ],return: [
        {
          type: "any",
          describe: "返回最后的计算结果"
        }
      ],callback: [
        {
          name: "callback",
          describe: "对所有的计算值进行自行处理"
        }
      ],
      callbackParameter: [
        {
          name: "valueArr",
          from: "callback",
          type: "Array",
          describe: "将运算结果或者返回值都依次储存在此数组中"
        }
      ],
      example: [
        `
        function fn(a){<br>
          return a*5<br>
        }<br>
        const res = parameterPassing(["1+2","5+6+$val$",fn,{name:'$val$'}])<br>
        console.log(res)
        `
      ]
    }
    ]
  },
  {
  id: "35", name: "antiShake", type: "Function", typeText: "函数", describe: "将函数包装为局部防抖函数<br>局部的含义为：此函数为单独的防抖函数，不与其他防抖函数共用防抖时间<br>相对于之后的全局防抖函数",
  data: [
    {
      parameter: [
        {
          name: "protectFunction",
          type: "Function",
          describe: "需要修饰的函数"
        },
        {
          name: "time",
          type: "Number",
          describe: "防抖时间，单位毫秒(ms)",
          default:"700"
        },
      ],
      return: [
        {
          type: "Function",
          describe: "返回包装好的函数"
        }
      ],
      example: [
        `
        function fn(){<br>
          console.log("测试")<br>
        }<br>
        antiShake(fn,1000)()<br>
        或者
        const fn2 = antiShake(fn,1000)<br>
        fn2()
        `
      ]
    }
    ]
  },
  {
  id: "36", name: "antiShakeOverall", type: "Function", typeText: "函数", describe: "将函数包装为全局防抖函数<br>全局的含义为：任何使用此方法包装的函数，都将全部共用同一个防抖时间<br>任何函数触发防抖之后其他函数防抖时间也会同步更新<br>此函数的默认防抖时间为700毫秒<br>需要调整防抖时间请使用setAntiShakeTime方法<br>相对于之前的局部防抖函数",
  data: [
    {
      parameter: [
        {
          name: "protectFunction",
          type: "Function",
          describe: "需要修饰的函数"
        }
      ],
      return: [
        {
          type: "Function",
          describe: "返回包装好的函数"
        }
      ],
      example: [
        `
        function fn(){<br>
          console.log("测试")<br>
        }<br>
        function fn2(){<br>
          console.log("测试2")<br>
        }<br>
        antiShakeOverall(fn)()<br>
        antiShakeOverall(fn2)()<br>
        或者
        const antiShakeFn = antiShakeOverall(fn)<br>
        const antiShakeFn2 = antiShakeOverall(fn2)<br>
        antiShakeFn()
        antiShakeFn2()
        `
      ]
    }
  ]},
  {
  id: "37", name: "setAntiShakeTime", type: "Function", typeText: "函数", describe: "设置全局防抖的时间，请参考antiShakeOverall方法",
  data: [
    {
      parameter: [
        {
          name: "time",
          type: "Number",
          describe: "全局防抖的时间，单位毫秒(ms)",
          default:700
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `setAntiShakeTime(2000)`
      ]
    }
  ]},
  {
  id: "38", name: "throttle", type: "Function", typeText: "函数", describe: "将函数包装为局部节流函数<br>局部的含义为：此函数为单独的节流函数，不与其他节流函数共用节流时间<br>相对于之后的全局节流函数",
  data: [
    {
      parameter: [
        {
          name: "protectFunction",
          type: "Function",
          describe: "需要修饰的函数"
        },
        {
          name: "time",
          type: "Number",
          describe: "节流时间，单位毫秒(ms)",
          default:"1000"
        },
      ],
      return: [
        {
          type: "Function",
          describe: "返回包装好的函数"
        }
      ],
      example: [
        `
        function fn(){<br>
          console.log("测试")<br>
        }<br>
        throttle(fn,1000)()<br>
        或者
        const fn2 = throttle(fn,1000)<br>
        fn2()
        `
      ]
    }
    ]
  },
  {
  id: "39", name: "throttleOverall", type: "Function", typeText: "函数", describe: "将函数包装为全局节流函数<br>全局的含义为：任何使用此方法包装的函数，都将全部共用同一个节流时间<br>任何函数触发节流之后其他函数节流时间也会同步更新<br>此函数的默认节流时间为1000毫秒<br>需要调整节流时间请使用setThrottleTime方法<br>相对于之前的局部节流函数",
  data: [
    {
      parameter: [
        {
          name: "protectFunction",
          type: "Function",
          describe: "需要修饰的函数"
        }
      ],
      return: [
        {
          type: "Function",
          describe: "返回包装好的函数"
        }
      ],
      example: [
        `
        function fn(){<br>
          console.log("测试")<br>
        }<br>
        function fn2(){<br>
          console.log("测试2")<br>
        }<br>
        throttleOverall(fn)()<br>
        throttleOverall(fn2)()<br>
        或者
        const throttleFn = throttleOverall(fn)<br>
        const throttleFn2 = throttleOverall(fn2)<br>
        throttleFn()
        throttleFn2()
        `
      ]
    }
  ]},
  {
  id: "40", name: "setThrottleTime", type: "Function", typeText: "函数", describe: "设置全局节流的时间，请参考throttleOverall方法",
  data: [
    {
      parameter: [
        {
          name: "time",
          type: "Number",
          describe: "全局节流的时间，单位毫秒(ms)",
          default:1000
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `setThrottleTime(2000)`
      ]
    }
  ]},
  {
  id: "41", name: "globalVariables", type: "Function", typeText: "函数", describe: "将参数对象内部的每一项都定义为全局变量或方法，方便统一管理。<br>此方法使用起来可能会有冲突风险",
  data: [
    {
      parameter: [
        {
          name: "variables",
          type: "Object",
          describe: "变量对象，可以在const属性中添加对象来定义常量"
        }
      ],
      return: [
        {
          type: "Object",
          describe: "变量对象"
        }
      ],
      example: [
        `globalVariables({<br>
          a:123,<br>
          b:'456',<br>
          const: {<br>
            c:789,<br>
            d:'890'<br>
          }<br>
        })`
      ]
    }
  ]},
  {
  id: "42", name: "evalSimulate", type: "Function", typeText: "函数", describe: "将字符串解析成语句进行执行",
  data: [
    {
      parameter: [
        {
          name: "str",
          type: "String",
          describe: "需要执行的字符串",
          default:"''"
        }
      ],
      return: [
        {
          type: "any",
          describe: "返回执行结果"
        }
      ],
      example: [
        `const data = evalSimulate('123+456')`
      ]
    }
    ]
  },
  {
  id: "43", name: "模式切换", type: "Function", typeText: "函数", describe: "用来切换移动端与PC端，用来让本JS工具里的组件类切换适配模式",
  data: [
    {
      name: "SwitchToMobile",describe: "切换到手机端模式",
      parameter: [
        {
          name: "baseSize",
          type: "Number",
          describe: "可选，用来设置移动端页面设计基础参考尺寸",
          default:"375"
        }
      ],
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `SwitchToMobile()`
      ]
    },
    {
      name: "SwitchToComputer",describe: "切换到PC端模式",
      return: [
        {
          type: "undefined"
        }
      ],
      example: [
        `SwitchToComputer()`
      ]
    },
  ]},
]

/* 演示 */
/* 
{
  id: "1", name: "userInput", type: "Function", typeText: "函数", describe: "描述",
  data: [
    {
      name: "方法名",describe: "方法描述",
      parameter: [
        {
          name: "参数",
          type: "参数类型",
          describe: "参数描述",
          default:"默认值"
        }
      ],
      return: [
        {
          type: "返回值类型",
          describe: "返回值描述"
        }
      ],callback: [
        {
          name: "回调函数",
          describe: "回调函数描述"
        }
      ],
      callbackParameter: [
        {
          name: "回调函数参数",
          from: "参数来自于哪个回调函数",
          type: "回调函数参数类型",
          describe: "回调函数参数描述"
        }
      ],
      example: [
        `示例详情`
      ]
    }
  ]},
*/
